1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
 
 
2
 
2
 
 
 
 
 
 
 
1
2
 
 
 
 
 
2
 
 
2
 
 
2
2
 
1
 
 
 
2
 
 
1
1
1
 
1
1
 
 
1
1
 
1
 
 
1
 
2
 
 
 
 
 
1
 
1
 
1
 
 
 
 
1
2
2
3
3
3
3
1
 
 
3
3
 
 
 
 
3
 
 
 
1
3
1
 
 
 
1
1
 
 
 
 
 
 
 
1
 
1
1
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
6
6
 
1
 
2
 
1
 
2
 
 
 
 
1
1
 
1
 
 
 
 
1
 
 
 
 
 
 
1
 
 
1
1
 
 
1
1
 
1
1
1
1
1
1
1
 
1
1
 
1
 
 
 
 
/*
example.js
 
quickstart example
 
instruction
    1. save this script as example.js
    2. run the shell command:
        $ npm install npmtest-parse-server && PORT=8081 node example.js
    3. play with the browser-demo on http://127.0.0.1:8081
*/
 
 
 
/* istanbul instrument in package npmtest_parse_server */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || (local.modeJs === 'browser'
            ? local.global.utility2_npmtest_parse_server
            : global.utility2_moduleExports);
        // export local
        local.global.local = local;
    }());
    switch (local.modeJs) {
 
 
 
    // post-init
    // run browser js-env code - post-init
    /* istanbul ignore next */
    case 'browser':
        local.testRunBrowser = function (event) {
            Eif (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('onreset'))) {
                // reset output
                Array.from(
                    document.querySelectorAll('body > .resettable')
                ).forEach(function (element) {
                    switch (element.tagName) {
                    case 'INPUT':
                    case 'TEXTAREA':
                        element.value = '';
                        break;
                    default:
                        element.textContent = '';
                    }
                });
            }
            switch (event && event.currentTarget && event.currentTarget.id) {
            case 'testRunButton1':
                // show tests
                Eif (document.querySelector('#testReportDiv1').style.display === 'none') {
                    document.querySelector('#testReportDiv1').style.display = 'block';
                    document.querySelector('#testRunButton1').textContent =
                        'hide internal test';
                    local.modeTest = true;
                    local.testRunDefault(local);
                // hide tests
                } else {
                    document.querySelector('#testReportDiv1').style.display = 'none';
                    document.querySelector('#testRunButton1').textContent = 'run internal test';
                }
                break;
            // custom-case
            default:
                break;
            }
            Iif (document.querySelector('#inputTextareaEval1') && (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('oneval')))) {
                // try to eval input-code
                try {
                    /*jslint evil: true*/
                    eval(document.querySelector('#inputTextareaEval1').value);
                } catch (errorCaught) {
                    console.error(errorCaught);
                }
            }
        };
        // log stderr and stdout to #outputTextareaStdout1
        ['error', 'log'].forEach(function (key) {
            console[key + '_original'] = console[key];
            console[key] = function () {
                var element;
                console[key + '_original'].apply(console, arguments);
                element = document.querySelector('#outputTextareaStdout1');
                Iif (!element) {
                    return;
                }
                // append text to #outputTextareaStdout1
                element.value += Array.from(arguments).map(function (arg) {
                    return typeof arg === 'string'
                        ? arg
                        : JSON.stringify(arg, null, 4);
                }).join(' ') + '\n';
                // scroll textarea to bottom
                element.scrollTop = element.scrollHeight;
            };
        });
        // init event-handling
        ['change', 'click', 'keyup'].forEach(function (event) {
            Array.from(document.querySelectorAll('.on' + event)).forEach(function (element) {
                element.addEventListener(event, local.testRunBrowser);
            });
        });
        // run tests
        local.testRunBrowser();
        break;
 
 
 
    // run node js-env code - post-init
    /* istanbul ignore next */
    case 'node':
        // export local
        module.exports = local;
        // require modules
        local.fs = require('fs');
        local.http = require('http');
        local.url = require('url');
        // init assets
        local.assetsDict = local.assetsDict || {};
        /* jslint-ignore-begin */
        local.assetsDict['/assets.index.template.html'] = '\
<!doctype html>\n\
<html lang="en">\n\
<head>\n\
<meta charset="UTF-8">\n\
<meta name="viewport" content="width=device-width, initial-scale=1">\n\
<title>{{env.npm_package_name}} (v{{env.npm_package_version}})</title>\n\
<style>\n\
/*csslint\n\
    box-sizing: false,\n\
    universal-selector: false\n\
*/\n\
* {\n\
    box-sizing: border-box;\n\
}\n\
body {\n\
    background: #dde;\n\
    font-family: Arial, Helvetica, sans-serif;\n\
    margin: 2rem;\n\
}\n\
body > * {\n\
    margin-bottom: 1rem;\n\
}\n\
.utility2FooterDiv {\n\
    margin-top: 20px;\n\
    text-align: center;\n\
}\n\
</style>\n\
<style>\n\
/*csslint\n\
*/\n\
textarea {\n\
    font-family: monospace;\n\
    height: 10rem;\n\
    width: 100%;\n\
}\n\
textarea[readonly] {\n\
    background: #ddd;\n\
}\n\
</style>\n\
</head>\n\
<body>\n\
<!-- utility2-comment\n\
<div id="ajaxProgressDiv1" style="background: #d00; height: 2px; left: 0; margin: 0; padding: 0; position: fixed; top: 0; transition: background 0.5s, width 1.5s; width: 25%;"></div>\n\
utility2-comment -->\n\
<h1>\n\
<!-- utility2-comment\n\
    <a\n\
        {{#if env.npm_package_homepage}}\n\
        href="{{env.npm_package_homepage}}"\n\
        {{/if env.npm_package_homepage}}\n\
        target="_blank"\n\
    >\n\
utility2-comment -->\n\
        {{env.npm_package_name}} (v{{env.npm_package_version}})\n\
<!-- utility2-comment\n\
    </a>\n\
utility2-comment -->\n\
</h1>\n\
<h3>{{env.npm_package_description}}</h3>\n\
<!-- utility2-comment\n\
<h4><a download href="assets.app.js">download standalone app</a></h4>\n\
<button class="onclick onreset" id="testRunButton1">run internal test</button><br>\n\
<div id="testReportDiv1" style="display: none;"></div>\n\
utility2-comment -->\n\
\n\
\n\
\n\
<label>stderr and stdout</label>\n\
<textarea class="resettable" id="outputTextareaStdout1" readonly></textarea>\n\
<!-- utility2-comment\n\
{{#if isRollup}}\n\
<script src="assets.app.js"></script>\n\
{{#unless isRollup}}\n\
utility2-comment -->\n\
<script src="assets.utility2.rollup.js"></script>\n\
<script src="jsonp.utility2._stateInit?callback=window.utility2._stateInit"></script>\n\
<script src="assets.npmtest_parse_server.rollup.js"></script>\n\
<script src="assets.example.js"></script>\n\
<script src="assets.test.js"></script>\n\
<!-- utility2-comment\n\
{{/if isRollup}}\n\
utility2-comment -->\n\
<div class="utility2FooterDiv">\n\
    [ this app was created with\n\
    <a href="https://github.com/kaizhu256/node-utility2" target="_blank">utility2</a>\n\
    ]\n\
</div>\n\
</body>\n\
</html>\n\
';
        /* jslint-ignore-end */
        Iif (local.templateRender) {
            local.assetsDict['/'] = local.templateRender(
                local.assetsDict['/assets.index.template.html'],
                {
                    env: local.objectSetDefault(local.env, {
                        npm_package_description: 'the greatest app in the world!',
                        npm_package_name: 'my-app',
                        npm_package_nameAlias: 'my_app',
                        npm_package_version: '0.0.1'
                    })
                }
            );
        } else {
            local.assetsDict['/'] = local.assetsDict['/assets.index.template.html']
                .replace((/\{\{env\.(\w+?)\}\}/g), function (match0, match1) {
                    // jslint-hack
                    String(match0);
                    switch (match1) {
                    case 'npm_package_description':
                        return 'the greatest app in the world!';
                    case 'npm_package_name':
                        return 'my-app';
                    case 'npm_package_nameAlias':
                        return 'my_app';
                    case 'npm_package_version':
                        return '0.0.1';
                    }
                });
        }
        // run the cli
        Eif (local.global.utility2_rollup || module !== require.main) {
            break;
        }
        local.assetsDict['/assets.example.js'] =
            local.assetsDict['/assets.example.js'] ||
            local.fs.readFileSync(__filename, 'utf8');
        // bug-workaround - long $npm_package_buildCustomOrg
        /* jslint-ignore-begin */
        local.assetsDict['/assets.npmtest_parse_server.rollup.js'] =
            local.assetsDict['/assets.npmtest_parse_server.rollup.js'] ||
            local.fs.readFileSync(
                local.npmtest_parse_server.__dirname + '/lib.npmtest_parse_server.js',
                'utf8'
            ).replace((/^#!/), '//');
        /* jslint-ignore-end */
        local.assetsDict['/favicon.ico'] = local.assetsDict['/favicon.ico'] || '';
        // if $npm_config_timeout_exit exists,
        // then exit this process after $npm_config_timeout_exit ms
        if (Number(process.env.npm_config_timeout_exit)) {
            setTimeout(process.exit, Number(process.env.npm_config_timeout_exit));
        }
        // start server
        if (local.global.utility2_serverHttp1) {
            break;
        }
        process.env.PORT = process.env.PORT || '8081';
        console.error('server starting on port ' + process.env.PORT);
        local.http.createServer(function (request, response) {
            request.urlParsed = local.url.parse(request.url);
            if (local.assetsDict[request.urlParsed.pathname] !== undefined) {
                response.end(local.assetsDict[request.urlParsed.pathname]);
                return;
            }
            response.statusCode = 404;
            response.end();
        }).listen(process.env.PORT);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
2
 
2
1
 
1
1
1
 
 
 
 
 
/* istanbul instrument in package npmtest_parse_server */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || local;
        // init lib
        local.local = local.npmtest_parse_server = local;
        // init exports
        if (local.modeJs === 'browser') {
            local.global.utility2_npmtest_parse_server = local;
        } else {
            module.exports = local;
            module.exports.__dirname = __dirname;
            module.exports.module = module;
        }
    }());
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
2
 
 
1
 
 
 
1
 
 
1
 
1
 
 
2
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
 
1
 
 
 
1
 
 
1
 
 
 
 
 
 
1
 
 
 
 
 
 
1
1
 
 
1
 
 
 
 
 
 
1
1
1
1
1
1
 
 
1
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
1
1
 
 
 
1
1
 
 
 
 
/* istanbul instrument in package npmtest_parse_server */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        switch (local.modeJs) {
        // re-init local from window.local
        case 'browser':
            local = local.global.utility2.objectSetDefault(
                local.global.utility2_rollup || local.global.local,
                local.global.utility2
            );
            break;
        // re-init local from example.js
        case 'node':
            local = (local.global.utility2_rollup || require('utility2'))
                .requireReadme();
            break;
        }
        // export local
        local.global.local = local;
    }());
 
 
 
    // run shared js-env code - function
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - function
    case 'browser':
        break;
 
 
 
    // run node js-env code - function
    case 'node':
        break;
    }
 
 
 
    // run shared js-env code - post-init
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - post-init
    case 'browser':
        local.testCase_browser_nullCase = local.testCase_browser_nullCase || function (
            options,
            onError
        ) {
        /*
         * this function will test browsers's null-case handling-behavior-behavior
         */
            onError(null, options);
        };
 
        // run tests
        local.nop(local.modeTest &&
            document.querySelector('#testRunButton1') &&
            document.querySelector('#testRunButton1').click());
        break;
 
 
 
    // run node js-env code - post-init
    /* istanbul ignore next */
    case 'node':
        local.testCase_buildApidoc_default = local.testCase_buildApidoc_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApidoc's default handling-behavior-behavior
         */
            options = { modulePathList: module.paths };
            local.buildApidoc(options, onError);
        };
 
        local.testCase_buildApp_default = local.testCase_buildApp_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApp's default handling-behavior-behavior
         */
            local.testCase_buildReadme_default(options, local.onErrorThrow);
            local.testCase_buildLib_default(options, local.onErrorThrow);
            local.testCase_buildTest_default(options, local.onErrorThrow);
            local.testCase_buildCustomOrg_default(options, local.onErrorThrow);
            options = [];
            local.buildApp(options, onError);
        };
 
        local.testCase_buildCustomOrg_default = local.testCase_buildCustomOrg_default ||
            function (options, onError) {
            /*
             * this function will test buildCustomOrg's default handling-behavior
             */
                options = {};
                local.buildCustomOrg(options, onError);
            };
 
        local.testCase_buildLib_default = local.testCase_buildLib_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildLib's default handling-behavior
         */
            options = {};
            local.buildLib(options, onError);
        };
 
        local.testCase_buildReadme_default = local.testCase_buildReadme_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildReadme's default handling-behavior-behavior
         */
            options = {};
            local.buildReadme(options, onError);
        };
 
        local.testCase_buildTest_default = local.testCase_buildTest_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildTest's default handling-behavior
         */
            options = {};
            local.buildTest(options, onError);
        };
 
        local.testCase_webpage_default = local.testCase_webpage_default || function (
            options,
            onError
        ) {
        /*
         * this function will test webpage's default handling-behavior
         */
            options = { modeCoverageMerge: true, url: local.serverLocalHost + '?modeTest=1' };
            local.browserTest(options, onError);
        };
 
        // run test-server
        local.testRunServer(local);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
 
 
 
 
 
1
1
1
 
1
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
1
 
 
 
 
 
 
 
1
 
 
 
1
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
'use strict';
// FileSystemAdapter
//
// Stores files in local file system
// Requires write access to the server's file system.
 
var fs = require('fs');
var path = require('path');
var pathSep = require('path').sep;
 
function FileSystemAdapter(options) {
  options = options || {};
  let filesSubDirectory = options.filesSubDirectory || '';
  this._filesDir = filesSubDirectory;
  this._mkdir(this._getApplicationDir());
  if (!this._applicationDirExist()) {
    throw "Files directory doesn't exist.";
  }
}
 
FileSystemAdapter.prototype.createFile = function(filename, data) {
  return new Promise((resolve, reject) => {
    let filepath = this._getLocalFilePath(filename);
    fs.writeFile(filepath, data, (err) => {
      if(err !== null) {
        return reject(err);
      }
      resolve(data);
    });
  });
}
 
FileSystemAdapter.prototype.deleteFile = function(filename) {
  return new Promise((resolve, reject) => {
    let filepath = this._getLocalFilePath(filename);
    fs.readFile( filepath , function (err, data) {
      if(err !== null) {
        return reject(err);
      }
      fs.unlink(filepath, (unlinkErr) => {
      if(err !== null) {
          return reject(unlinkErr);
        }
        resolve(data);
      });
    });
 
  });
}
 
FileSystemAdapter.prototype.getFileData = function(filename) {
  return new Promise((resolve, reject) => {
    let filepath = this._getLocalFilePath(filename);
    fs.readFile( filepath , function (err, data) {
      if(err !== null) {
        return reject(err);
      }
      resolve(data);
    });
  });
}
 
FileSystemAdapter.prototype.getFileLocation = function(config, filename) {
  return config.mount + '/files/' + config.applicationId + '/' + encodeURIComponent(filename);
}
 
/*
  Helpers
 --------------- */
 FileSystemAdapter.prototype._getApplicationDir = function() {
  if (this._filesDir) {
    return path.join('files', this._filesDir);
  } else {
    return 'files';
  }
 }
 
FileSystemAdapter.prototype._applicationDirExist = function() {
  return fs.existsSync(this._getApplicationDir());
}
 
FileSystemAdapter.prototype._getLocalFilePath = function(filename) {
  let applicationDir = this._getApplicationDir();
  if (!fs.existsSync(applicationDir)) {
    this._mkdir(applicationDir);
  }
  return path.join(applicationDir, encodeURIComponent(filename));
}
 
FileSystemAdapter.prototype._mkdir = function(dirPath) {
  // snippet found on -> https://gist.github.com/danherbert-epam/3960169
  let dirs = dirPath.split(pathSep);
  var root = "";
 
  while (dirs.length > 0) {
    var dir = dirs.shift();
    if (dir === "") { // If directory starts with a /, the first path will be an empty string.
      root = pathSep;
    }
    if (!fs.existsSync(path.join(root, dir))) {
      try {
        fs.mkdirSync(path.join(root, dir));
      }
      catch (e) {
        if ( e.code == 'EACCES' ) {
          throw new Error("PERMISSION ERROR: In order to use the FileSystemAdapter, write access to the server's file system is required.");
        }
      }
    }
    root = path.join(root, dir, pathSep);
  }
}
 
module.exports = FileSystemAdapter;
module.exports.default = FileSystemAdapter;
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
 
 
 
 
 
1
 
 
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
3
 
1
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
1
 
 
 
1
1
 
"use strict";
 
// TODO: apn does not support the new HTTP/2 protocal. It is fine to use it in V1,
// but probably we will replace it in the future.
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
 
var _apn = require('apn');
 
var _apn2 = _interopRequireDefault(_apn);
 
var _parse = require('parse');
 
var _parse2 = _interopRequireDefault(_parse);
 
var _npmlog = require('npmlog');
 
var _npmlog2 = _interopRequireDefault(_npmlog);
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
var LOG_PREFIX = 'parse-server-push-adapter APNS';
 
/**
 * Create a new connection to the APN service.
 * @constructor
 * @param {Object|Array} args An argument or a list of arguments to config APNS connection
 * @param {String} args.cert The filename of the connection certificate to load from disk
 * @param {String} args.key The filename of the connection key to load from disk
 * @param {String} args.pfx The filename for private key, certificate and CA certs in PFX or PKCS12 format, it will overwrite cert and key
 * @param {String} args.passphrase The passphrase for the connection key, if required
 * @param {String} args.bundleId The bundleId for cert
 * @param {Boolean} args.production Specifies which environment to connect to: Production (if true) or Sandbox
 */
function APNS(args) {
  var _this = this;
 
  // typePushConfig can be an array.
  var apnsArgsList = [];
  if (Array.isArray(args)) {
    apnsArgsList = apnsArgsList.concat(args);
  } else if ((typeof args === 'undefined' ? 'undefined' : _typeof(args)) === 'object') {
    apnsArgsList.push(args);
  } else {
    throw new _parse2.default.Error(_parse2.default.Error.PUSH_MISCONFIGURED, 'APNS Configuration is invalid');
  }
 
  this.conns = [];
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;
 
  try {
    var _loop = function _loop() {
      var apnsArgs = _step.value;
 
      var conn = new _apn2.default.Connection(apnsArgs);
      if (!apnsArgs.bundleId) {
        throw new _parse2.default.Error(_parse2.default.Error.PUSH_MISCONFIGURED, 'BundleId is mssing for %j', apnsArgs);
      }
      conn.bundleId = apnsArgs.bundleId;
      // Set the priority of the conns, prod cert has higher priority
      if (apnsArgs.production) {
        conn.priority = 0;
      } else {
        conn.priority = 1;
      }
 
      // Set apns client callbacks
      conn.on('connected', function () {
        _npmlog2.default.verbose(LOG_PREFIX, 'APNS Connection %d Connected', conn.index);
      });
 
      conn.on('transmissionError', function (errCode, notification, apnDevice) {
        handleTransmissionError(_this.conns, errCode, notification, apnDevice);
      });
 
      conn.on('timeout', function () {
        _npmlog2.default.verbose(LOG_PREFIX, 'APNS Connection %d Timeout', conn.index);
      });
 
      conn.on('disconnected', function () {
        _npmlog2.default.verbose(LOG_PREFIX, 'APNS Connection %d Disconnected', conn.index);
      });
 
      conn.on('socketError', function () {
        _npmlog2.default.verbose(LOG_PREFIX, 'APNS Connection %d Socket Error', conn.index);
      });
 
      conn.on('transmitted', function (notification, device) {
        if (device.callback) {
          device.callback({
            notification: notification,
            transmitted: true,
            device: {
              deviceType: device.deviceType,
              deviceToken: device.token.toString('hex')
            }
          });
        }
        _npmlog2.default.verbose(LOG_PREFIX, 'APNS Connection %d Notification transmitted to %s', conn.index, device.token.toString('hex'));
      });
 
      _this.conns.push(conn);
    };
 
    for (var _iterator = apnsArgsList[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      _loop();
    }
    // Sort the conn based on priority ascending, high pri first
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }
 
  this.conns.sort(function (s1, s2) {
    return s1.priority - s2.priority;
  });
  // Set index of conns
  for (var index = 0; index < this.conns.length; index++) {
    this.conns[index].index = index;
  }
}
 
/**
 * Send apns request.
 * @param {Object} data The data we need to send, the format is the same with api request body
 * @param {Array} devices A array of devices
 * @returns {Object} A promise which is resolved immediately
 */
APNS.prototype.send = function (data, devices) {
  var _this2 = this;
 
  var coreData = data.data;
  var expirationTime = data['expiration_time'];
  var notification = generateNotification(coreData, expirationTime);
  var allPromises = [];
  var devicesPerConnIndex = {};
  // Start by clustering the devices per connections
  devices.forEach(function (device) {
    var qualifiedConnIndexs = chooseConns(_this2.conns, device);
    if (qualifiedConnIndexs.length == 0) {
      _npmlog2.default.error(LOG_PREFIX, 'no qualified connections for %s %s', device.appIdentifier, device.deviceToken);
      var promise = Promise.resolve({
        transmitted: false,
        device: {
          deviceToken: device.deviceToken,
          deviceType: device.deviceType
        },
        result: { error: 'No connection available' }
      });
      allPromises.push(promise);
    } else {
      var apnDevice = new _apn2.default.Device(device.deviceToken);
      apnDevice.connIndex = qualifiedConnIndexs[0];
      if (device.appIdentifier) {
        apnDevice.appIdentifier = device.appIdentifier;
      }
      devicesPerConnIndex[apnDevice.connIndex] = devicesPerConnIndex[apnDevice.connIndex] || [];
      devicesPerConnIndex[apnDevice.connIndex].push(apnDevice);
    }
  });
 
  allPromises = Object.keys(devicesPerConnIndex).reduce(function (memo, connIndex) {
    var devices = devicesPerConnIndex[connIndex];
    // Create a promise, attach the callback
    var promises = devices.map(function (apnDevice) {
      return new Promise(function (resolve, reject) {
        apnDevice.callback = resolve;
      });
    });
    var conn = _this2.conns[connIndex];
    conn.pushNotification(notification, devices);
    return memo.concat(promises);
  }, allPromises);
 
  return Promise.all(allPromises);
};
 
function handleTransmissionError(conns, errCode, notification, apnDevice) {
  // This means the error notification is not in the cache anymore or the recepient is missing,
  // we just ignore this case
  if (!notification || !apnDevice) {
    return;
  }
 
  // If currentConn can not send the push notification, we try to use the next available conn.
  // Since conns is sorted by priority, the next conn means the next low pri conn.
  // If there is no conn available, we give up on sending the notification to that device.
  var qualifiedConnIndexs = chooseConns(conns, apnDevice);
  var currentConnIndex = apnDevice.connIndex;
 
  var newConnIndex = -1;
  // Find the next element of currentConnIndex in qualifiedConnIndexs
  for (var index = 0; index < qualifiedConnIndexs.length - 1; index++) {
    if (qualifiedConnIndexs[index] === currentConnIndex) {
      newConnIndex = qualifiedConnIndexs[index + 1];
      break;
    }
  }
  // There is no more available conns, we give up in this case
  if (newConnIndex < 0 || newConnIndex >= conns.length) {
    if (apnDevice.callback) {
      _npmlog2.default.error(LOG_PREFIX, 'cannot find vaild connection for ' + apnDevice.token.toString('hex'));
      apnDevice.callback({
        response: { error: 'APNS can not find vaild connection for ' + apnDevice.token.toString('hex'), code: errCode },
        status: errCode,
        transmitted: false,
        device: {
          deviceType: apnDevice.deviceType,
          deviceToken: apnDevice.token.toString('hex')
        }
      });
    }
    return;
  }
 
  var newConn = conns[newConnIndex];
  // Update device conn info
  apnDevice.connIndex = newConnIndex;
  // Use the new conn to send the notification
  newConn.pushNotification(notification, apnDevice);
}
 
function chooseConns(conns, device) {
  // If device does not have appIdentifier, all conns maybe proper connections.
  // Otherwise we try to match the appIdentifier with bundleId
  var qualifiedConns = [];
  for (var index = 0; index < conns.length; index++) {
    var _conn = conns[index];
    // If the device we need to send to does not have
    // appIdentifier, any conn could be a qualified connection
    if (!device.appIdentifier || device.appIdentifier === '') {
      qualifiedConns.push(index);
      continue;
    }
    if (device.appIdentifier === _conn.bundleId) {
      qualifiedConns.push(index);
    }
  }
  return qualifiedConns;
}
 
/**
 * Generate the apns notification from the data we get from api request.
 * @param {Object} coreData The data field under api request body
 * @param {number} expirationTime The expiration time in milliseconds since Jan 1 1970
 * @returns {Object} A apns notification
 */
function generateNotification(coreData, expirationTime) {
  var notification = new _apn2.default.notification();
  var payload = {};
  for (var key in coreData) {
    switch (key) {
      case 'alert':
        notification.setAlertText(coreData.alert);
        break;
      case 'badge':
        notification.badge = coreData.badge;
        break;
      case 'sound':
        notification.sound = coreData.sound;
        break;
      case 'content-available':
        notification.setNewsstandAvailable(true);
        var isAvailable = coreData['content-available'] === 1;
        notification.setContentAvailable(isAvailable);
        break;
      case 'mutable-content':
        var isMutable = coreData['mutable-content'] === 1;
        notification.setMutableContent(isMutable);
        break;
      case 'category':
        notification.category = coreData.category;
        break;
      default:
        payload[key] = coreData[key];
        break;
    }
  }
  notification.payload = payload;
  notification.expiry = expirationTime / 1000;
  return notification;
}
 
APNS.generateNotification = generateNotification;
 
Iif (process.env.TESTING) {
  APNS.chooseConns = chooseConns;
  APNS.handleTransmissionError = handleTransmissionError;
}
module.exports = APNS;
exports.default = APNS;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
 
1
 
 
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
3
 
1
1
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
1
 
1
 
 
 
1
1
 
"use strict";
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
 
var _parse = require('parse');
 
var _parse2 = _interopRequireDefault(_parse);
 
var _npmlog = require('npmlog');
 
var _npmlog2 = _interopRequireDefault(_npmlog);
 
var _nodeGcm = require('node-gcm');
 
var _nodeGcm2 = _interopRequireDefault(_nodeGcm);
 
var _PushAdapterUtils = require('./PushAdapterUtils');
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
var LOG_PREFIX = 'parse-server-push-adapter GCM';
var GCMTimeToLiveMax = 4 * 7 * 24 * 60 * 60; // GCM allows a max of 4 weeks
var GCMRegistrationTokensMax = 1000;
 
function GCM(args) {
  if ((typeof args === 'undefined' ? 'undefined' : _typeof(args)) !== 'object' || !args.apiKey) {
    throw new _parse2.default.Error(_parse2.default.Error.PUSH_MISCONFIGURED, 'GCM Configuration is invalid');
  }
  this.sender = new _nodeGcm2.default.Sender(args.apiKey);
}
 
/**
 * Send gcm request.
 * @param {Object} data The data we need to send, the format is the same with api request body
 * @param {Array} devices A array of devices
 * @returns {Object} A promise which is resolved after we get results from gcm
 */
GCM.prototype.send = function (data, devices) {
  var _this = this;
 
  var pushId = (0, _PushAdapterUtils.randomString)(10);
  // Make a new array
  devices = devices.slice(0);
  var timestamp = Date.now();
  // For android, we can only have 1000 recepients per send, so we need to slice devices to
  // chunk if necessary
  var slices = sliceDevices(devices, GCMRegistrationTokensMax);
  if (slices.length > 1) {
    _npmlog2.default.verbose(LOG_PREFIX, 'the number of devices exceeds ' + GCMRegistrationTokensMax);
    // Make 1 send per slice
    var _promises = slices.reduce(function (memo, slice) {
      var promise = _this.send(data, slice, timestamp);
      memo.push(promise);
      return memo;
    }, []);
    return _parse2.default.Promise.when(_promises).then(function (results) {
      var allResults = results.reduce(function (memo, result) {
        return memo.concat(result);
      }, []);
      return _parse2.default.Promise.as(allResults);
    });
  }
  // get the devices back...
  devices = slices[0];
 
  var expirationTime = void 0;
  // We handle the expiration_time convertion in push.js, so expiration_time is a valid date
  // in Unix epoch time in milliseconds here
  if (data['expiration_time']) {
    expirationTime = data['expiration_time'];
  }
  // Generate gcm payload
  // PushId is not a formal field of GCM, but Parse Android SDK uses this field to deduplicate push notifications
  var gcmPayload = generateGCMPayload(data, pushId, timestamp, expirationTime);
  // Make and send gcm request
  var message = new _nodeGcm2.default.Message(gcmPayload);
 
  // Build a device map
  var devicesMap = devices.reduce(function (memo, device) {
    memo[device.deviceToken] = device;
    return memo;
  }, {});
 
  var deviceTokens = Object.keys(devicesMap);
 
  var promises = deviceTokens.map(function () {
    return new _parse2.default.Promise();
  });
  var registrationTokens = deviceTokens;
  var length = registrationTokens.length;
  _npmlog2.default.verbose(LOG_PREFIX, 'sending to ' + length + ' ' + (length > 1 ? 'devices' : 'device'));
  this.sender.send(message, { registrationTokens: registrationTokens }, 5, function (error, response) {
    // example response:
    /*
    {  "multicast_id":7680139367771848000,
      "success":0,
      "failure":4,
      "canonical_ids":0,
      "results":[ {"error":"InvalidRegistration"},
        {"error":"InvalidRegistration"},
        {"error":"InvalidRegistration"},
        {"error":"InvalidRegistration"}] }
    */
    if (error) {
      _npmlog2.default.error(LOG_PREFIX, 'send errored: %s', JSON.stringify(error, null, 4));
    } else {
      _npmlog2.default.verbose(LOG_PREFIX, 'GCM Response: %s', JSON.stringify(response, null, 4));
    }
 
    var _ref = response || {},
        results = _ref.results,
        multicast_id = _ref.multicast_id;
 
    registrationTokens.forEach(function (token, index) {
      var promise = promises[index];
      var result = results ? results[index] : undefined;
      var device = devicesMap[token];
      device.deviceType = 'android';
      var resolution = {
        device: device,
        multicast_id: multicast_id,
        response: error || result
      };
      if (!result || result.error) {
        resolution.transmitted = false;
      } else {
        resolution.transmitted = true;
      }
      promise.resolve(resolution);
    });
  });
  return _parse2.default.Promise.when(promises);
};
 
/**
 * Generate the gcm payload from the data we get from api request.
 * @param {Object} requestData The request body
 * @param {String} pushId A random string
 * @param {Number} timeStamp A number whose format is the Unix Epoch
 * @param {Number|undefined} expirationTime A number whose format is the Unix Epoch or undefined
 * @returns {Object} A promise which is resolved after we get results from gcm
 */
function generateGCMPayload(requestData, pushId, timeStamp, expirationTime) {
  var payload = {
    priority: 'high'
  };
  payload.data = {
    data: requestData.data,
    push_id: pushId,
    time: new Date(timeStamp).toISOString()
  };
  if (requestData.content_available) {
    payload.content_available = requestData.content_available;
  }
  if (requestData.notification) {
    payload.notification = requestData.notification;
  }
  if (expirationTime) {
    // The timeStamp and expiration is in milliseconds but gcm requires second
    var timeToLive = Math.floor((expirationTime - timeStamp) / 1000);
    if (timeToLive < 0) {
      timeToLive = 0;
    }
    if (timeToLive >= GCMTimeToLiveMax) {
      timeToLive = GCMTimeToLiveMax;
    }
    payload.timeToLive = timeToLive;
  }
  return payload;
}
 
/**
 * Slice a list of devices to several list of devices with fixed chunk size.
 * @param {Array} devices An array of devices
 * @param {Number} chunkSize The size of the a chunk
 * @returns {Array} An array which contaisn several arries of devices with fixed chunk size
 */
function sliceDevices(devices, chunkSize) {
  var chunkDevices = [];
  while (devices.length > 0) {
    chunkDevices.push(devices.splice(0, chunkSize));
  }
  return chunkDevices;
}
 
GCM.generateGCMPayload = generateGCMPayload;
 
Iif (process.env.TESTING) {
  GCM.sliceDevices = sliceDevices;
}
 
module.exports = GCM;
exports.default = GCM;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
 
1
 
 
1
 
3
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
4
 
1
 
1
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
1
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ParsePushAdapter = undefined;
 
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; Eif ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { Eif (protoProps) defineProperties(Constructor.prototype, protoProps); Eif (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
var _parse = require('parse');
 
var _parse2 = _interopRequireDefault(_parse);
 
var _npmlog = require('npmlog');
 
var _npmlog2 = _interopRequireDefault(_npmlog);
 
var _APNS = require('./APNS');
 
var _APNS2 = _interopRequireDefault(_APNS);
 
var _GCM = require('./GCM');
 
var _GCM2 = _interopRequireDefault(_GCM);
 
var _PushAdapterUtils = require('./PushAdapterUtils');
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
var LOG_PREFIX = 'parse-server-push-adapter';
 
var ParsePushAdapter = exports.ParsePushAdapter = function () {
  function ParsePushAdapter() {
    var pushConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
    _classCallCheck(this, ParsePushAdapter);
 
    this.supportsPushTracking = true;
 
    this.validPushTypes = ['ios', 'osx', 'tvos', 'android', 'fcm'];
    this.senderMap = {};
    // used in PushController for Dashboard Features
    this.feature = {
      immediatePush: true
    };
    var pushTypes = Object.keys(pushConfig);
 
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;
 
    try {
      for (var _iterator = pushTypes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var pushType = _step.value;
 
        if (this.validPushTypes.indexOf(pushType) < 0) {
          throw new _parse2.default.Error(_parse2.default.Error.PUSH_MISCONFIGURED, 'Push to ' + pushTypes + ' is not supported');
        }
        switch (pushType) {
          case 'ios':
          case 'tvos':
          case 'osx':
            this.senderMap[pushType] = new _APNS2.default(pushConfig[pushType]);
            break;
          case 'android':
          case 'fcm':
            this.senderMap[pushType] = new _GCM2.default(pushConfig[pushType]);
            break;
        }
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
  }
 
  _createClass(ParsePushAdapter, [{
    key: 'getValidPushTypes',
    value: function getValidPushTypes() {
      return this.validPushTypes;
    }
  }, {
    key: 'send',
    value: function send(data, installations) {
      var _this = this;
 
      var deviceMap = (0, _PushAdapterUtils.classifyInstallations)(installations, this.validPushTypes);
      var sendPromises = [];
 
      var _loop = function _loop(pushType) {
        var sender = _this.senderMap[pushType];
        var devices = deviceMap[pushType];
 
        if (Array.isArray(devices) && devices.length > 0) {
          if (!sender) {
            _npmlog2.default.verbose(LOG_PREFIX, 'Can not find sender for push type ' + pushType + ', ' + data);
            var results = devices.map(function (device) {
              return Promise.resolve({
                device: device,
                transmitted: false,
                response: { 'error': 'Can not find sender for push type ' + pushType + ', ' + data }
              });
            });
            sendPromises.push(Promise.all(results));
          } else {
            sendPromises.push(sender.send(data, devices));
          }
        }
      };
 
      for (var pushType in deviceMap) {
        _loop(pushType);
      }
      return Promise.all(sendPromises).then(function (promises) {
        // flatten all
        return [].concat.apply([], promises);
      });
    }
  }], [{
    key: 'classifyInstallations',
    value: function classifyInstallations(installations, validTypes) {
      return (0, _PushAdapterUtils.classifyInstallations)(installations, validTypes);
    }
  }]);
 
  return ParsePushAdapter;
}();
 
exports.default = ParsePushAdapter;
 
module.exports = ParsePushAdapter;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
 
1
 
 
1
1
 
1
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.classifyInstallations = classifyInstallations;
exports.randomString = randomString;
 
var _crypto = require('crypto');
 
/**g
   * Classify the device token of installations based on its device type.
   * @param {Object} installations An array of installations
   * @param {Array} validPushTypes An array of valid push types(string)
   * @returns {Object} A map whose key is device type and value is an array of device
   */
function classifyInstallations(installations, validPushTypes) {
  // Init deviceTokenMap, create a empty array for each valid pushType
  var deviceMap = {};
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;
 
  try {
    for (var _iterator = validPushTypes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var validPushType = _step.value;
 
      deviceMap[validPushType] = [];
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }
 
  var _iteratorNormalCompletion2 = true;
  var _didIteratorError2 = false;
  var _iteratorError2 = undefined;
 
  try {
    for (var _iterator2 = installations[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
      var installation = _step2.value;
 
      // No deviceToken, ignore
      if (!installation.deviceToken) {
        continue;
      }
      var devices = deviceMap[installation.pushType] || deviceMap[installation.deviceType] || null;
      if (Array.isArray(devices)) {
        devices.push({
          deviceToken: installation.deviceToken,
          deviceType: installation.deviceType,
          appIdentifier: installation.appIdentifier
        });
      }
    }
  } catch (err) {
    _didIteratorError2 = true;
    _iteratorError2 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion2 && _iterator2.return) {
        _iterator2.return();
      }
    } finally {
      if (_didIteratorError2) {
        throw _iteratorError2;
      }
    }
  }
 
  return deviceMap;
}
 
function randomString(size) {
  if (size === 0) {
    throw new Error('Zero-length randomString is useless.');
  }
  var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789';
  var objectId = '';
  var bytes = (0, _crypto.randomBytes)(size);
  for (var i = 0; i < bytes.length; ++i) {
    objectId += chars[bytes.readUInt8(i) % chars.length];
  }
  return objectId;
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
 
 
 
 
1
 
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
4
 
1
 
1
1
1
1
1
 
"use strict";
// ParsePushAdapter is the default implementation of
// PushAdapter, it uses GCM for android push and APNS
// for ios push.
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.utils = exports.GCM = exports.APNS = exports.ParsePushAdapter = undefined;
 
var _npmlog = require('npmlog');
 
var _npmlog2 = _interopRequireDefault(_npmlog);
 
var _ParsePushAdapter = require('./ParsePushAdapter');
 
var _ParsePushAdapter2 = _interopRequireDefault(_ParsePushAdapter);
 
var _GCM = require('./GCM');
 
var _GCM2 = _interopRequireDefault(_GCM);
 
var _APNS = require('./APNS');
 
var _APNS2 = _interopRequireDefault(_APNS);
 
var _PushAdapterUtils = require('./PushAdapterUtils');
 
var utils = _interopRequireWildcard(_PushAdapterUtils);
 
function _interopRequireWildcard(obj) { Eif (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
Iif (process.env.VERBOSE || process.env.VERBOSE_PARSE_SERVER_PUSH_ADAPTER) {
  _npmlog2.default.level = 'verbose';
}exports.default = _ParsePushAdapter2.default;
exports.ParsePushAdapter = _ParsePushAdapter2.default;
exports.APNS = _APNS2.default;
exports.GCM = _GCM2.default;
exports.utils = utils;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
1
1
1
 
 
 
 
1
1
 
 
1
 
 
 
 
 
 
1
1
1
1
1
 
1
 
 
1
1
1
1
 
 
 
 
 
 
1
1
1
1
1
 
1
1
 
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
1
 
 
 
1
 
 
 
1
 
 
 
1
 
 
 
1
 
 
 
 
1
 
 
 
 
1
 
 
 
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
"use strict"
var hasUnicode = require("has-unicode")
var ansi = require("ansi")
var align = {
  center: require("lodash.pad"),
  left:   require("lodash.padend"),
  right:  require("lodash.padstart")
}
var defaultStream = process.stderr
function isTTY() {
  return process.stderr.isTTY
}
function getWritableTTYColumns() {
  // Writing to the final column wraps the line
  // We have to use stdout here, because Node's magic SIGWINCH handler only
  // updates process.stdout, not process.stderr
  return process.stdout.columns - 1
}
 
var ProgressBar = module.exports = function (options, cursor) {
  Iif (! options) options = {}
  Eif (! cursor && options.write) {
    cursor = options
    options = {}
  }
  Iif (! cursor) {
    cursor = ansi(defaultStream)
  }
  this.cursor = cursor
  this.showing = false
  this.theme = options.theme || (hasUnicode() ? ProgressBar.unicode : ProgressBar.ascii)
  this.template = options.template || [
    {type: "name", separated: true, length: 25},
    {type: "spinner", separated: true},
    {type: "startgroup"},
    {type: "completionbar"},
    {type: "endgroup"}
  ]
  this.updatefreq = options.maxUpdateFrequency == null ? 50 : options.maxUpdateFrequency
  this.lastName = ""
  this.lastCompleted = 0
  this.spun = 0
  this.last = new Date(0)
 
  var self = this
  this._handleSizeChange = function () {
    if (!self.showing) return
    self.hide()
    self.show()
  }
}
ProgressBar.prototype = {}
 
ProgressBar.unicode = {
  startgroup: "╢",
  endgroup: "╟",
  complete: "█",
  incomplete: "░",
  spinner: "▀▐▄▌",
  subsection: "→"
}
 
ProgressBar.ascii = {
  startgroup: "|",
  endgroup: "|",
  complete: "#",
  incomplete: "-",
  spinner: "-\\|/",
  subsection: "->"
}
 
ProgressBar.prototype.setTheme = function(theme) {
  this.theme = theme
}
 
ProgressBar.prototype.setTemplate = function(template) {
  this.template = template
}
 
ProgressBar.prototype._enableResizeEvents = function() {
  process.stdout.on('resize', this._handleSizeChange)
}
 
ProgressBar.prototype._disableResizeEvents = function() {
  process.stdout.removeListener('resize', this._handleSizeChange)
}
 
ProgressBar.prototype.disable = function() {
  this.hide()
  this.disabled = true
}
 
ProgressBar.prototype.enable = function() {
  this.disabled = false
  this.show()
}
 
ProgressBar.prototype.hide = function() {
  if (!isTTY()) return
  if (this.disabled) return
  this.cursor.show()
  if (this.showing) this.cursor.up(1)
  this.cursor.horizontalAbsolute(0).eraseLine()
  this.showing = false
}
 
var repeat = function (str, count) {
  var out = ""
  for (var ii=0; ii<count; ++ii) out += str
  return out
}
 
ProgressBar.prototype.pulse = function(name) {
  ++ this.spun
  if (! this.showing) return
  if (this.disabled) return
 
  var baseName = this.lastName
  name = name
       ? ( baseName
         ? baseName + " " + this.theme.subsection + " " + name
         : null )
       : baseName
  this.show(name)
  this.lastName = baseName
}
 
ProgressBar.prototype.show = function(name, completed) {
  name = this.lastName = name || this.lastName
  completed = this.lastCompleted = completed || this.lastCompleted
 
  if (!isTTY()) return
  if (this.disabled) return
  if (! this.spun && ! completed) return
  if (this.tryAgain) return
  var self = this
 
  if (this.showing && new Date() - this.last < this.updatefreq) {
    this.tryAgain = setTimeout(function () {
      self.tryAgain = null
      if (self.disabled) return
      if (! self.spun && ! completed) return
      drawBar()
    }, this.updatefreq - (new Date() - this.last))
    return
  }
 
  return drawBar()
 
  function drawBar() {
    var values = {
      name: name,
      spinner: self.spun,
      completed: completed
    }
 
    self.last = new Date()
 
    var statusline = self.renderTemplate(self.theme, self.template, values)
 
    if (self.showing) self.cursor.up(1)
    self.cursor
        .hide()
        .horizontalAbsolute(0)
        .write(statusline.substr(0, getWritableTTYColumns()) + "\n")
        .show()
 
    self.showing = true
  }
}
 
ProgressBar.prototype.renderTemplate = function (theme, template, values) {
  values.startgroup = theme.startgroup
  values.endgroup = theme.endgroup
  values.spinner = values.spinner
    ? theme.spinner.substr(values.spinner % theme.spinner.length,1)
    : ""
 
  var output = {prebar: "", postbar: ""}
  var status = "prebar"
  var self = this
  template.forEach(function(T) {
    if (typeof T === "string") {
      output[status] += T
      return
    }
    if (T.type === "completionbar") {
      status = "postbar"
      return
    }
    if (!values.hasOwnProperty(T.type)) throw new Error("Unknown template value '"+T.type+"'")
    var value = self.renderValue(T, values[T.type])
    if (value === "") return
    var sofar = output[status].length
    var lastChar = sofar ? output[status][sofar-1] : null
    if (T.separated && sofar && lastChar !== " ") {
      output[status] += " "
    }
    output[status] += value
    if (T.separated) output[status] += " "
  })
 
  var bar = ""
  if (status === "postbar") {
    var nonBarLen = output.prebar.length + output.postbar.length
 
    var barLen = getWritableTTYColumns() - nonBarLen
    var sofar = Math.round(barLen * Math.max(0,Math.min(1,values.completed||0)))
    var rest = barLen - sofar
    bar = repeat(theme.complete, sofar)
        + repeat(theme.incomplete, rest)
  }
 
  return output.prebar + bar + output.postbar
}
ProgressBar.prototype.renderValue = function (template, value) {
  if (value == null || value === "") return ""
  var maxLength = template.maxLength || template.length
  var minLength = template.minLength || template.length
  var alignWith = align[template.align] || align.left
//  if (maxLength) value = value.substr(-1 * maxLength)
  if (maxLength) value = value.substr(0, maxLength)
  if (minLength) value = alignWith(value, minLength)
  return value
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
1
1
1
1
1
 
1
1
1
 
 
1
1
 
 
 
1
 
 
 
 
 
1
 
1
1
 
 
1
 
1
 
1
 
 
 
 
1
 
 
 
 
1
1
 
 
 
 
1
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
3
 
 
1
 
 
 
 
1
 
 
 
 
 
 
1
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
1
 
1
1
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
7
7
7
7
 
 
 
 
 
 
 
7
 
 
1
1
 
1
1
1
1
1
1
1
1
1
1
 
 
1
 
 
'use strict'
var Progress = require('are-we-there-yet')
var Gauge = require('gauge')
var EE = require('events').EventEmitter
var log = exports = module.exports = new EE
var util = require('util')
 
var ansi = require('ansi')
log.cursor = ansi(process.stderr)
log.stream = process.stderr
 
// by default, let ansi decide based on tty-ness.
var colorEnabled = undefined
log.enableColor = function () {
  colorEnabled = true
  this.cursor.enabled = true
}
log.disableColor = function () {
  colorEnabled = false
  this.cursor.enabled = false
}
 
// default level
log.level = 'info'
 
log.gauge = new Gauge(log.cursor)
log.tracker = new Progress.TrackerGroup()
 
// no progress bars unless asked
log.progressEnabled = false
 
var gaugeTheme = undefined
 
log.enableUnicode = function () {
  gaugeTheme = Gauge.unicode
  log.gauge.setTheme(gaugeTheme)
}
 
log.disableUnicode = function () {
  gaugeTheme = Gauge.ascii
  log.gauge.setTheme(gaugeTheme)
}
 
var gaugeTemplate = undefined
log.setGaugeTemplate = function (template) {
  gaugeTemplate = template
  log.gauge.setTemplate(gaugeTemplate)
}
 
log.enableProgress = function () {
  if (this.progressEnabled) return
  this.progressEnabled = true
  if (this._pause) return
  this.tracker.on('change', this.showProgress)
  this.gauge.enable()
  this.showProgress()
}
 
log.disableProgress = function () {
  if (!this.progressEnabled) return
  this.clearProgress()
  this.progressEnabled = false
  this.tracker.removeListener('change', this.showProgress)
  this.gauge.disable()
}
 
var trackerConstructors = ['newGroup', 'newItem', 'newStream']
 
var mixinLog = function (tracker) {
  // mixin the public methods from log into the tracker
  // (except: conflicts and one's we handle specially)
  Object.keys(log).forEach(function (P) {
    if (P[0] === '_') return
    if (trackerConstructors.filter(function (C) { return C === P }).length) return
    if (tracker[P]) return
    if (typeof log[P] !== 'function') return
    var func = log[P]
    tracker[P] = function () {
      return func.apply(log, arguments)
    }
  })
  // if the new tracker is a group, make sure any subtrackers get
  // mixed in too
  if (tracker instanceof Progress.TrackerGroup) {
    trackerConstructors.forEach(function (C) {
      var func = tracker[C]
      tracker[C] = function () { return mixinLog(func.apply(tracker, arguments)) }
    })
  }
  return tracker
}
 
// Add tracker constructors to the top level log object
trackerConstructors.forEach(function (C) {
  log[C] = function () { return mixinLog(this.tracker[C].apply(this.tracker, arguments)) }
})
 
log.clearProgress = function () {
  if (!this.progressEnabled) return
  this.gauge.hide()
}
 
log.showProgress = function (name, completed) {
  if (!this.progressEnabled) return
  if (completed == null) completed = this.tracker.completed()
  this.gauge.show(name, completed)
}.bind(log) // bind for use in tracker's on-change listener
 
// temporarily stop emitting, but don't drop
log.pause = function () {
  this._paused = true
}
 
log.resume = function () {
  if (!this._paused) return
  this._paused = false
 
  var b = this._buffer
  this._buffer = []
  b.forEach(function (m) {
    this.emitLog(m)
  }, this)
  if (this.progressEnabled) this.enableProgress()
}
 
log._buffer = []
 
var id = 0
log.record = []
log.maxRecordSize = 10000
log.log = function (lvl, prefix, message) {
  var l = this.levels[lvl]
  if (l === undefined) {
    return this.emit('error', new Error(util.format(
      'Undefined log level: %j', lvl)))
  }
 
  var a = new Array(arguments.length - 2)
  var stack = null
  for (var i = 2; i < arguments.length; i ++) {
    var arg = a[i-2] = arguments[i]
 
    // resolve stack traces to a plain string.
    if (typeof arg === 'object' && arg &&
        (arg instanceof Error) && arg.stack) {
      arg.stack = stack = arg.stack + ''
    }
  }
  if (stack) a.unshift(stack + '\n')
  message = util.format.apply(util, a)
 
  var m = { id: id++,
            level: lvl,
            prefix: String(prefix || ''),
            message: message,
            messageRaw: a }
 
  this.emit('log', m)
  this.emit('log.' + lvl, m)
  if (m.prefix) this.emit(m.prefix, m)
 
  this.record.push(m)
  var mrs = this.maxRecordSize
  var n = this.record.length - mrs
  if (n > mrs / 10) {
    var newSize = Math.floor(mrs * 0.9)
    this.record = this.record.slice(-1 * newSize)
  }
 
  this.emitLog(m)
}.bind(log)
 
log.emitLog = function (m) {
  if (this._paused) {
    this._buffer.push(m)
    return
  }
  if (this.progressEnabled) this.gauge.pulse(m.prefix)
  var l = this.levels[m.level]
  if (l === undefined) return
  if (l < this.levels[this.level]) return
  if (l > 0 && !isFinite(l)) return
 
  var style = log.style[m.level]
  var disp = log.disp[m.level] || m.level
  this.clearProgress()
  m.message.split(/\r?\n/).forEach(function (line) {
    if (this.heading) {
      this.write(this.heading, this.headingStyle)
      this.write(' ')
    }
    this.write(disp, log.style[m.level])
    var p = m.prefix || ''
    if (p) this.write(' ')
    this.write(p, this.prefixStyle)
    this.write(' ' + line + '\n')
  }, this)
  this.showProgress()
}
 
log.write = function (msg, style) {
  if (!this.cursor) return
  if (this.stream !== this.cursor.stream) {
    this.cursor = ansi(this.stream, { enabled: colorEnabled })
    var options = {}
    if (gaugeTheme != null) options.theme = gaugeTheme
    if (gaugeTemplate != null) options.template = gaugeTemplate
    this.gauge = new Gauge(options, this.cursor)
  }
 
  style = style || {}
  if (style.fg) this.cursor.fg[style.fg]()
  if (style.bg) this.cursor.bg[style.bg]()
  if (style.bold) this.cursor.bold()
  if (style.underline) this.cursor.underline()
  if (style.inverse) this.cursor.inverse()
  if (style.beep) this.cursor.beep()
  this.cursor.write(msg).reset()
}
 
log.addLevel = function (lvl, n, style, disp) {
  if (!disp) disp = lvl
  this.levels[lvl] = n
  this.style[lvl] = style
  Eif (!this[lvl]) this[lvl] = function () {
    var a = new Array(arguments.length + 1)
    a[0] = lvl
    for (var i = 0; i < arguments.length; i ++) {
      a[i + 1] = arguments[i]
    }
    return this.log.apply(this, a)
  }.bind(this)
  this.disp[lvl] = disp
}
 
log.prefixStyle = { fg: 'magenta' }
log.headingStyle = { fg: 'white', bg: 'black' }
 
log.style = {}
log.levels = {}
log.disp = {}
log.addLevel('silly', -Infinity, { inverse: true }, 'sill')
log.addLevel('verbose', 1000, { fg: 'blue', bg: 'black' }, 'verb')
log.addLevel('info', 2000, { fg: 'green' })
log.addLevel('http', 3000, { fg: 'green', bg: 'black' })
log.addLevel('warn', 4000, { fg: 'black', bg: 'yellow' }, 'WARN')
log.addLevel('error', 5000, { fg: 'red', bg: 'black' }, 'ERR!')
log.addLevel('silent', Infinity)
 
// allow 'error' prefix
log.on('error', function(){})
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
 
 
 
 
1
1
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
'use strict';
// S3Adapter
//
// Stores Parse files in AWS S3.
 
var AWS = require('aws-sdk');
var optionsFromArguments = require('./lib/optionsFromArguments');
 
// Creates an S3 session.
// Providing AWS access, secret keys and bucket are mandatory
// Region will use sane defaults if omitted
function S3Adapter() {
  var options = optionsFromArguments(arguments);
  this._region = options.region;
  this._bucket = options.bucket;
  this._bucketPrefix = options.bucketPrefix;
  this._directAccess = options.directAccess;
  this._baseUrl = options.baseUrl;
  this._baseUrlDirect = options.baseUrlDirect;
  this._signatureVersion = options.signatureVersion;
  this._globalCacheControl = options.globalCacheControl;
 
  let s3Options = {
    params: { Bucket: this._bucket },
    region: this._region,
    signatureVersion: this._signatureVersion,
    globalCacheControl: this._globalCacheControl
  };
 
  if (options.accessKey && options.secretKey) {
    s3Options.accessKeyId = options.accessKey;
    s3Options.secretAccessKey = options.secretKey;
  }
 
  Object.assign(s3Options, options.s3overrides);
 
  this._s3Client = new AWS.S3(s3Options);
  this._hasBucket = false;
}
 
S3Adapter.prototype.createBucket = function() {
  var promise;
  if (this._hasBucket) {
    promise = Promise.resolve();
  } else {
    promise = new Promise((resolve) => {
      this._s3Client.createBucket(() => {
        this._hasBucket = true;
        resolve();
      });
    });
  }
  return promise;
}
 
// For a given config object, filename, and data, store a file in S3
// Returns a promise containing the S3 object creation response
S3Adapter.prototype.createFile = function(filename, data, contentType) {
  let params = {
    Key: this._bucketPrefix + filename,
    Body: data
  };
  if (this._directAccess) {
    params.ACL = "public-read"
  }
  if (contentType) {
    params.ContentType = contentType;
  }
  if(this._globalCacheControl) {
    params.CacheControl = this._globalCacheControl;
  }
  return this.createBucket().then(() => {
    return new Promise((resolve, reject) => {
      this._s3Client.upload(params, (err, data) => {
        if (err !== null) {
          return reject(err);
        }
        resolve(data);
      });
    });
  });
}
 
S3Adapter.prototype.deleteFile = function(filename) {
  return this.createBucket().then(() => {
    return new Promise((resolve, reject) => {
      let params = {
        Key: this._bucketPrefix + filename
      };
      this._s3Client.deleteObject(params, (err, data) =>{
        if(err !== null) {
          return reject(err);
        }
        resolve(data);
      });
    });
  });
}
 
// Search for and return a file if found by filename
// Returns a promise that succeeds with the buffer result from S3
S3Adapter.prototype.getFileData = function(filename) {
  let params = {Key: this._bucketPrefix + filename};
  return this.createBucket().then(() => {
    return new Promise((resolve, reject) => {
      this._s3Client.getObject(params, (err, data) => {
        if (err !== null) {
          return reject(err);
        }
        // Something happened here...
        if (data && !data.Body) {
          return reject(data);
        }
        resolve(data.Body);
      });
    });
  });
}
 
// Generates and returns the location of a file stored in S3 for the given request and filename
// The location is the direct S3 link if the option is set, otherwise we serve the file through parse-server
S3Adapter.prototype.getFileLocation = function(config, filename) {
  filename = encodeURIComponent(filename);
  if (this._directAccess) {
    if (this._baseUrl && this._baseUrlDirect) {
      return `${this._baseUrl}/${filename}`;
    } else if (this._baseUrl) {
      return `${this._baseUrl}/${this._bucketPrefix + filename}`;
    } else {
      return `https://${this._bucket}.s3.amazonaws.com/${this._bucketPrefix + filename}`;
    }
  }
  return (config.mount + '/files/' + config.applicationId + '/' + filename);
}
 
module.exports = S3Adapter;
module.exports.default = S3Adapter;
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
 
1
 
1
 
 
 
 
 
 
 
1
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
'use strict';
 
const DEFAULT_S3_REGION = 'us-east-1';
 
function requiredOrFromEnvironment(options, key, env) {
  options[key] = options[key] || process.env[env];
  if (!options[key]) {
    throw `S3Adapter requires option '${key}' or env. variable ${env}`;
  }
  return options;
}
 
function fromEnvironmentOrDefault(options, key, env, defaultValue) {
  options[key] = options[key] || process.env[env] || defaultValue;
  return options;
}
 
const optionsFromArguments = function optionsFromArguments(args) {
  const stringOrOptions = args[0];
  let options = {};
  let s3overrides = {};
  let otherOptions;
 
  if (typeof stringOrOptions == 'string') {
    if (args.length == 1) {
      options.bucket = stringOrOptions;
    } else if (args.length == 2) {
      options.bucket = stringOrOptions;
      if (typeof args[1] != 'object') {
        throw new Error('Failed to configure S3Adapter. Arguments don\'t make sense');
      }
      otherOptions = args[1];
    } else if (args.length > 2) {
      if (typeof args[1] != 'string' || typeof args[2] != 'string') {
        throw new Error('Failed to configure S3Adapter. Arguments don\'t make sense');
      }
      options.accessKey = args[0];
      options.secretKey = args[1];
      options.bucket = args[2];
      otherOptions = args[3];
    }
 
    if (otherOptions) {
      options.bucketPrefix = otherOptions.bucketPrefix;
      options.directAccess = otherOptions.directAccess;
      options.baseUrl = otherOptions.baseUrl;
      options.baseUrlDirect = otherOptions.baseUrlDirect;
      options.signatureVersion = otherOptions.signatureVersion;
      options.globalCacheControl = otherOptions.globalCacheControl;
    }
  } else {
    if (args.length == 1) {
      Object.assign(options, stringOrOptions);
    } else if (args.length == 2) {
      Object.assign(options, stringOrOptions);
      s3overrides = args[1];
      options.bucket = s3overrides.params.Bucket;
    } else if (args.length > 2) {
      throw new Error('Failed to configure S3Adapter. Arguments don\'t make sense');
    }
  }
 
  options = requiredOrFromEnvironment(options, 'bucket', 'S3_BUCKET');
  options = fromEnvironmentOrDefault(options, 'accessKey', 'S3_ACCESS_KEY', null);
  options = fromEnvironmentOrDefault(options, 'secretKey', 'S3_SECRET_KEY', null);
  options = fromEnvironmentOrDefault(options, 'bucketPrefix', 'S3_BUCKET_PREFIX', '');
  options = fromEnvironmentOrDefault(options, 'region', 'S3_REGION', DEFAULT_S3_REGION);
  options = fromEnvironmentOrDefault(options, 'directAccess', 'S3_DIRECT_ACCESS', false);
  options = fromEnvironmentOrDefault(options, 'baseUrl', 'S3_BASE_URL', null);
  options = fromEnvironmentOrDefault(options, 'baseUrlDirect', 'S3_BASE_URL_DIRECT', false);
  options = fromEnvironmentOrDefault(options, 'signatureVersion', 'S3_SIGNATURE_VERSION', 'v4');
  options = fromEnvironmentOrDefault(
    options, 'globalCacheControl', 'S3_GLOBAL_CACHE_CONTROL', null);
  options.s3overrides = s3overrides;
 
  return options;
}
 
module.exports = optionsFromArguments;
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 
 
1
 
 
1
 
8
 
 
1
 
1
 
1
 
1
 
1
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.AccountLockout = undefined;
 
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; Eif ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { Eif (protoProps) defineProperties(Constructor.prototype, protoProps); Iif (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // This class handles the Account Lockout Policy settings.
 
 
var _node = require('parse/node');
 
var _node2 = _interopRequireDefault(_node);
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
var AccountLockout = exports.AccountLockout = function () {
  function AccountLockout(user, config) {
    _classCallCheck(this, AccountLockout);
 
    this._user = user;
    this._config = config;
  }
 
  /**
   * set _failed_login_count to value
   */
 
 
  _createClass(AccountLockout, [{
    key: '_setFailedLoginCount',
    value: function _setFailedLoginCount(value) {
      var query = {
        username: this._user.username
      };
 
      var updateFields = {
        _failed_login_count: value
      };
 
      return this._config.database.update('_User', query, updateFields);
    }
 
    /**
     * check if the _failed_login_count field has been set
     */
 
  }, {
    key: '_isFailedLoginCountSet',
    value: function _isFailedLoginCountSet() {
      var _this = this;
 
      return new Promise(function (resolve, reject) {
        var query = {
          username: _this._user.username,
          _failed_login_count: { $exists: true }
        };
 
        _this._config.database.find('_User', query).then(function (users) {
          if (Array.isArray(users) && users.length > 0) {
            resolve(true);
          } else {
            resolve(false);
          }
        }).catch(function (err) {
          reject(err);
        });
      });
    }
 
    /**
     * if _failed_login_count is NOT set then set it to 0
     * else do nothing
     */
 
  }, {
    key: '_initFailedLoginCount',
    value: function _initFailedLoginCount() {
      var _this2 = this;
 
      return new Promise(function (resolve, reject) {
 
        _this2._isFailedLoginCountSet().then(function (failedLoginCountIsSet) {
          if (!failedLoginCountIsSet) {
            return _this2._setFailedLoginCount(0);
          } else {
            return Promise.resolve();
          }
        }).then(function () {
          resolve();
        }).catch(function (err) {
          reject(err);
        });
      });
    }
 
    /**
     * increment _failed_login_count by 1
     */
 
  }, {
    key: '_incrementFailedLoginCount',
    value: function _incrementFailedLoginCount() {
      var query = {
        username: this._user.username
      };
 
      var updateFields = { _failed_login_count: { __op: 'Increment', amount: 1 } };
 
      return this._config.database.update('_User', query, updateFields);
    }
 
    /**
     * if the failed login count is greater than the threshold
     * then sets lockout expiration to 'currenttime + accountPolicy.duration', i.e., account is locked out for the next 'accountPolicy.duration' minutes
     * else do nothing
     */
 
  }, {
    key: '_setLockoutExpiration',
    value: function _setLockoutExpiration() {
      var _this3 = this;
 
      return new Promise(function (resolve, reject) {
        var query = {
          username: _this3._user.username,
          _failed_login_count: { $gte: _this3._config.accountLockout.threshold }
        };
 
        var now = new Date();
 
        var updateFields = {
          _account_lockout_expires_at: _node2.default._encode(new Date(now.getTime() + _this3._config.accountLockout.duration * 60 * 1000))
        };
 
        _this3._config.database.update('_User', query, updateFields).then(function () {
          resolve();
        }).catch(function (err) {
          if (err && err.code && err.message && err.code === 101 && err.message === 'Object not found.') {
            resolve(); // nothing to update so we are good
          } else {
            reject(err); // unknown error
          }
        });
      });
    }
 
    /**
     * if _account_lockout_expires_at > current_time and _failed_login_count > threshold
     *   reject with account locked error
     * else
     *   resolve
     */
 
  }, {
    key: '_notLocked',
    value: function _notLocked() {
      var _this4 = this;
 
      return new Promise(function (resolve, reject) {
        var query = {
          username: _this4._user.username,
          _account_lockout_expires_at: { $gt: _node2.default._encode(new Date()) },
          _failed_login_count: { $gte: _this4._config.accountLockout.threshold }
        };
 
        _this4._config.database.find('_User', query).then(function (users) {
          if (Array.isArray(users) && users.length > 0) {
            reject(new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Your account is locked due to multiple failed login attempts. Please try again after ' + _this4._config.accountLockout.duration + ' minute(s)'));
          } else {
            resolve();
          }
        }).catch(function (err) {
          reject(err);
        });
      });
    }
 
    /**
     * set and/or increment _failed_login_count
     * if _failed_login_count > threshold
     *   set the _account_lockout_expires_at to current_time + accountPolicy.duration
     * else
     *   do nothing
     */
 
  }, {
    key: '_handleFailedLoginAttempt',
    value: function _handleFailedLoginAttempt() {
      var _this5 = this;
 
      return new Promise(function (resolve, reject) {
        _this5._initFailedLoginCount().then(function () {
          return _this5._incrementFailedLoginCount();
        }).then(function () {
          return _this5._setLockoutExpiration();
        }).then(function () {
          resolve();
        }).catch(function (err) {
          reject(err);
        });
      });
    }
 
    /**
     * handle login attempt if the Account Lockout Policy is enabled
     */
 
  }, {
    key: 'handleLoginAttempt',
    value: function handleLoginAttempt(loginSuccessful) {
      var _this6 = this;
 
      if (!this._config.accountLockout) {
        return Promise.resolve();
      }
 
      return new Promise(function (resolve, reject) {
        _this6._notLocked().then(function () {
          if (loginSuccessful) {
            return _this6._setFailedLoginCount(0);
          } else {
            return _this6._handleFailedLoginAttempt();
          }
        }).then(function () {
          resolve();
        }).catch(function (err) {
          reject(err);
        });
      });
    }
  }]);
 
  return AccountLockout;
}();
 
exports.default = AccountLockout;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
 
1
 
1
1
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
1
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
'use strict';
 
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
 
var Parse = require('parse/node').Parse;
var RestQuery = require('./RestQuery');
 
// An Auth object tells you who is requesting something and whether
// the master key was used.
// userObject is a Parse.User and can be null if there's no user.
function Auth() {
  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      config = _ref.config,
      _ref$isMaster = _ref.isMaster,
      isMaster = _ref$isMaster === undefined ? false : _ref$isMaster,
      user = _ref.user,
      installationId = _ref.installationId;
 
  this.config = config;
  this.installationId = installationId;
  this.isMaster = isMaster;
  this.user = user;
 
  // Assuming a users roles won't change during a single request, we'll
  // only load them once.
  this.userRoles = [];
  this.fetchedRoles = false;
  this.rolePromise = null;
}
 
// Whether this auth could possibly modify the given user id.
// It still could be forbidden via ACLs even if this returns true.
Auth.prototype.couldUpdateUserId = function (userId) {
  if (this.isMaster) {
    return true;
  }
  if (this.user && this.user.id === userId) {
    return true;
  }
  return false;
};
 
// A helper to get a master-level Auth object
function master(config) {
  return new Auth({ config: config, isMaster: true });
}
 
// A helper to get a nobody-level Auth object
function nobody(config) {
  return new Auth({ config: config, isMaster: false });
}
 
// Returns a promise that resolves to an Auth object
var getAuthForSessionToken = function getAuthForSessionToken() {
  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      config = _ref2.config,
      sessionToken = _ref2.sessionToken,
      installationId = _ref2.installationId;
 
  return config.cacheController.user.get(sessionToken).then(function (userJSON) {
    if (userJSON) {
      var cachedUser = Parse.Object.fromJSON(userJSON);
      return Promise.resolve(new Auth({ config: config, isMaster: false, installationId: installationId, user: cachedUser }));
    }
 
    var restOptions = {
      limit: 1,
      include: 'user'
    };
 
    var query = new RestQuery(config, master(config), '_Session', { sessionToken: sessionToken }, restOptions);
    return query.execute().then(function (response) {
      var results = response.results;
      if (results.length !== 1 || !results[0]['user']) {
        throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid session token');
      }
 
      var now = new Date(),
          expiresAt = results[0].expiresAt ? new Date(results[0].expiresAt.iso) : undefined;
      if (expiresAt < now) {
        throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Session token is expired.');
      }
      var obj = results[0]['user'];
      delete obj.password;
      obj['className'] = '_User';
      obj['sessionToken'] = sessionToken;
      config.cacheController.user.put(sessionToken, obj);
      var userObject = Parse.Object.fromJSON(obj);
      return new Auth({ config: config, isMaster: false, installationId: installationId, user: userObject });
    });
  });
};
 
var getAuthForLegacySessionToken = function getAuthForLegacySessionToken() {
  var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      config = _ref3.config,
      sessionToken = _ref3.sessionToken,
      installationId = _ref3.installationId;
 
  var restOptions = {
    limit: 1
  };
  var query = new RestQuery(config, master(config), '_User', { sessionToken: sessionToken }, restOptions);
  return query.execute().then(function (response) {
    var results = response.results;
    if (results.length !== 1) {
      throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid legacy session token');
    }
    var obj = results[0];
    obj.className = '_User';
    var userObject = Parse.Object.fromJSON(obj);
    return new Auth({ config: config, isMaster: false, installationId: installationId, user: userObject });
  });
};
 
// Returns a promise that resolves to an array of role names
Auth.prototype.getUserRoles = function () {
  if (this.isMaster || !this.user) {
    return Promise.resolve([]);
  }
  if (this.fetchedRoles) {
    return Promise.resolve(this.userRoles);
  }
  if (this.rolePromise) {
    return this.rolePromise;
  }
  this.rolePromise = this._loadRoles();
  return this.rolePromise;
};
 
// Iterates through the role tree and compiles a users roles
Auth.prototype._loadRoles = function () {
  var _this = this;
 
  var cacheAdapter = this.config.cacheController;
  return cacheAdapter.role.get(this.user.id).then(function (cachedRoles) {
    if (cachedRoles != null) {
      _this.fetchedRoles = true;
      _this.userRoles = cachedRoles;
      return Promise.resolve(cachedRoles);
    }
 
    var restWhere = {
      'users': {
        __type: 'Pointer',
        className: '_User',
        objectId: _this.user.id
      }
    };
    // First get the role ids this user is directly a member of
    var query = new RestQuery(_this.config, master(_this.config), '_Role', restWhere, {});
    return query.execute().then(function (response) {
      var results = response.results;
      if (!results.length) {
        _this.userRoles = [];
        _this.fetchedRoles = true;
        _this.rolePromise = null;
 
        cacheAdapter.role.put(_this.user.id, _this.userRoles);
        return Promise.resolve(_this.userRoles);
      }
      var rolesMap = results.reduce(function (m, r) {
        m.names.push(r.name);
        m.ids.push(r.objectId);
        return m;
      }, { ids: [], names: [] });
 
      // run the recursive finding
      return _this._getAllRolesNamesForRoleIds(rolesMap.ids, rolesMap.names).then(function (roleNames) {
        _this.userRoles = roleNames.map(function (r) {
          return 'role:' + r;
        });
        _this.fetchedRoles = true;
        _this.rolePromise = null;
 
        cacheAdapter.role.put(_this.user.id, _this.userRoles);
        return Promise.resolve(_this.userRoles);
      });
    });
  });
};
 
// Given a list of roleIds, find all the parent roles, returns a promise with all names
Auth.prototype._getAllRolesNamesForRoleIds = function (roleIDs) {
  var _this2 = this;
 
  var names = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  var queriedRoles = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 
  var ins = roleIDs.filter(function (roleID) {
    return queriedRoles[roleID] !== true;
  }).map(function (roleID) {
    // mark as queried
    queriedRoles[roleID] = true;
    return {
      __type: 'Pointer',
      className: '_Role',
      objectId: roleID
    };
  });
 
  // all roles are accounted for, return the names
  if (ins.length == 0) {
    return Promise.resolve([].concat(_toConsumableArray(new Set(names))));
  }
  // Build an OR query across all parentRoles
  var restWhere = void 0;
  if (ins.length == 1) {
    restWhere = { 'roles': ins[0] };
  } else {
    restWhere = { 'roles': { '$in': ins } };
  }
  var query = new RestQuery(this.config, master(this.config), '_Role', restWhere, {});
  return query.execute().then(function (response) {
    var results = response.results;
    // Nothing found
    if (!results.length) {
      return Promise.resolve(names);
    }
    // Map the results with all Ids and names
    var resultMap = results.reduce(function (memo, role) {
      memo.names.push(role.name);
      memo.ids.push(role.objectId);
      return memo;
    }, { ids: [], names: [] });
    // store the new found names
    names = names.concat(resultMap.names);
    // find the next ones, circular roles will be cut
    return _this2._getAllRolesNamesForRoleIds(resultMap.ids, names, queriedRoles);
  }).then(function (names) {
    return Promise.resolve([].concat(_toConsumableArray(new Set(names))));
  });
};
 
module.exports = {
  Auth: Auth,
  master: master,
  nobody: nobody,
  getAuthForSessionToken: getAuthForSessionToken,
  getAuthForLegacySessionToken: getAuthForLegacySessionToken
};
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
'use strict';
 
var semver = require('semver');
 
function compatible(compatibleSDK) {
  return function (clientSDK) {
    if (typeof clientSDK === 'string') {
      clientSDK = fromString(clientSDK);
    }
    // REST API, or custom SDK
    if (!clientSDK) {
      return true;
    }
    var clientVersion = clientSDK.version;
    var compatiblityVersion = compatibleSDK[clientSDK.sdk];
    return semver.satisfies(clientVersion, compatiblityVersion);
  };
}
 
function supportsForwardDelete(clientSDK) {
  return compatible({
    js: '>=1.9.0'
  })(clientSDK);
}
 
function fromString(version) {
  var versionRE = /([-a-zA-Z]+)([0-9\.]+)/;
  var match = version.toLowerCase().match(versionRE);
  if (match && match.length === 3) {
    return {
      sdk: match[1],
      version: match[2]
    };
  }
  return undefined;
}
 
module.exports = {
  compatible: compatible,
  supportsForwardDelete: supportsForwardDelete,
  fromString: fromString
};
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
 
 
1
 
 
1
 
17
 
 
 
1
 
1
 
1
 
1
 
1
 
1
 
3
 
1
 
1
 
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
1
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Config = undefined;
 
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { Eif (protoProps) defineProperties(Constructor.prototype, protoProps); Eif (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // A Config object provides information about how a specific app is
// configured.
// mount is the URL for the root of the API; includes http, domain, etc.
 
var _cache = require('./cache');
 
var _cache2 = _interopRequireDefault(_cache);
 
var _SchemaCache = require('./Controllers/SchemaCache');
 
var _SchemaCache2 = _interopRequireDefault(_SchemaCache);
 
var _DatabaseController = require('./Controllers/DatabaseController');
 
var _DatabaseController2 = _interopRequireDefault(_DatabaseController);
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
function removeTrailingSlash(str) {
  if (!str) {
    return str;
  }
  if (str.endsWith("/")) {
    str = str.substr(0, str.length - 1);
  }
  return str;
}
 
var Config = exports.Config = function () {
  function Config(applicationId, mount) {
    _classCallCheck(this, Config);
 
    var cacheInfo = _cache2.default.get(applicationId);
    if (!cacheInfo) {
      return;
    }
 
    this.applicationId = applicationId;
    this.jsonLogs = cacheInfo.jsonLogs;
    this.masterKey = cacheInfo.masterKey;
    this.clientKey = cacheInfo.clientKey;
    this.javascriptKey = cacheInfo.javascriptKey;
    this.dotNetKey = cacheInfo.dotNetKey;
    this.restAPIKey = cacheInfo.restAPIKey;
    this.webhookKey = cacheInfo.webhookKey;
    this.fileKey = cacheInfo.fileKey;
    this.allowClientClassCreation = cacheInfo.allowClientClassCreation;
    this.userSensitiveFields = cacheInfo.userSensitiveFields;
 
    // Create a new DatabaseController per request
    if (cacheInfo.databaseController) {
      var schemaCache = new _SchemaCache2.default(cacheInfo.cacheController, cacheInfo.schemaCacheTTL, cacheInfo.enableSingleSchemaCache);
      this.database = new _DatabaseController2.default(cacheInfo.databaseController.adapter, schemaCache);
    }
 
    this.schemaCacheTTL = cacheInfo.schemaCacheTTL;
    this.enableSingleSchemaCache = cacheInfo.enableSingleSchemaCache;
 
    this.serverURL = cacheInfo.serverURL;
    this.publicServerURL = removeTrailingSlash(cacheInfo.publicServerURL);
    this.verifyUserEmails = cacheInfo.verifyUserEmails;
    this.preventLoginWithUnverifiedEmail = cacheInfo.preventLoginWithUnverifiedEmail;
    this.emailVerifyTokenValidityDuration = cacheInfo.emailVerifyTokenValidityDuration;
    this.accountLockout = cacheInfo.accountLockout;
    this.passwordPolicy = cacheInfo.passwordPolicy;
    this.appName = cacheInfo.appName;
 
    this.analyticsController = cacheInfo.analyticsController;
    this.cacheController = cacheInfo.cacheController;
    this.hooksController = cacheInfo.hooksController;
    this.filesController = cacheInfo.filesController;
    this.pushController = cacheInfo.pushController;
    this.pushControllerQueue = cacheInfo.pushControllerQueue;
    this.pushWorker = cacheInfo.pushWorker;
    this.hasPushSupport = cacheInfo.hasPushSupport;
    this.loggerController = cacheInfo.loggerController;
    this.userController = cacheInfo.userController;
    this.authDataManager = cacheInfo.authDataManager;
    this.customPages = cacheInfo.customPages || {};
    this.mount = removeTrailingSlash(mount);
    this.liveQueryController = cacheInfo.liveQueryController;
    this.sessionLength = cacheInfo.sessionLength;
    this.expireInactiveSessions = cacheInfo.expireInactiveSessions;
    this.generateSessionExpiresAt = this.generateSessionExpiresAt.bind(this);
    this.generateEmailVerifyTokenExpiresAt = this.generateEmailVerifyTokenExpiresAt.bind(this);
    this.revokeSessionOnPasswordReset = cacheInfo.revokeSessionOnPasswordReset;
  }
 
  _createClass(Config, [{
    key: 'generateEmailVerifyTokenExpiresAt',
    value: function generateEmailVerifyTokenExpiresAt() {
      if (!this.verifyUserEmails || !this.emailVerifyTokenValidityDuration) {
        return undefined;
      }
      var now = new Date();
      return new Date(now.getTime() + this.emailVerifyTokenValidityDuration * 1000);
    }
  }, {
    key: 'generatePasswordResetTokenExpiresAt',
    value: function generatePasswordResetTokenExpiresAt() {
      if (!this.passwordPolicy || !this.passwordPolicy.resetTokenValidityDuration) {
        return undefined;
      }
      var now = new Date();
      return new Date(now.getTime() + this.passwordPolicy.resetTokenValidityDuration * 1000);
    }
  }, {
    key: 'generateSessionExpiresAt',
    value: function generateSessionExpiresAt() {
      if (!this.expireInactiveSessions) {
        return undefined;
      }
      var now = new Date();
      return new Date(now.getTime() + this.sessionLength * 1000);
    }
  }, {
    key: 'mount',
    get: function get() {
      var mount = this._mount;
      if (this.publicServerURL) {
        mount = this.publicServerURL;
      }
      return mount;
    },
    set: function set(newValue) {
      this._mount = newValue;
    }
  }, {
    key: 'invalidLinkURL',
    get: function get() {
      return this.customPages.invalidLink || this.publicServerURL + '/apps/invalid_link.html';
    }
  }, {
    key: 'verifyEmailSuccessURL',
    get: function get() {
      return this.customPages.verifyEmailSuccess || this.publicServerURL + '/apps/verify_email_success.html';
    }
  }, {
    key: 'choosePasswordURL',
    get: function get() {
      return this.customPages.choosePassword || this.publicServerURL + '/apps/choose_password';
    }
  }, {
    key: 'requestResetPasswordURL',
    get: function get() {
      return this.publicServerURL + '/apps/' + this.applicationId + '/request_password_reset';
    }
  }, {
    key: 'passwordResetSuccessURL',
    get: function get() {
      return this.customPages.passwordResetSuccess || this.publicServerURL + '/apps/password_reset_success.html';
    }
  }, {
    key: 'parseFrameURL',
    get: function get() {
      return this.customPages.parseFrameURL;
    }
  }, {
    key: 'verifyEmailURL',
    get: function get() {
      return this.publicServerURL + '/apps/' + this.applicationId + '/verify_email';
    }
  }], [{
    key: 'validate',
    value: function validate(_ref) {
      var verifyUserEmails = _ref.verifyUserEmails,
          userController = _ref.userController,
          appName = _ref.appName,
          publicServerURL = _ref.publicServerURL,
          revokeSessionOnPasswordReset = _ref.revokeSessionOnPasswordReset,
          expireInactiveSessions = _ref.expireInactiveSessions,
          sessionLength = _ref.sessionLength,
          emailVerifyTokenValidityDuration = _ref.emailVerifyTokenValidityDuration,
          accountLockout = _ref.accountLockout,
          passwordPolicy = _ref.passwordPolicy;
 
      var emailAdapter = userController.adapter;
      if (verifyUserEmails) {
        this.validateEmailConfiguration({ emailAdapter: emailAdapter, appName: appName, publicServerURL: publicServerURL, emailVerifyTokenValidityDuration: emailVerifyTokenValidityDuration });
      }
 
      this.validateAccountLockoutPolicy(accountLockout);
 
      this.validatePasswordPolicy(passwordPolicy);
 
      if (typeof revokeSessionOnPasswordReset !== 'boolean') {
        throw 'revokeSessionOnPasswordReset must be a boolean value';
      }
 
      if (publicServerURL) {
        if (!publicServerURL.startsWith("http://") && !publicServerURL.startsWith("https://")) {
          throw "publicServerURL should be a valid HTTPS URL starting with https://";
        }
      }
 
      this.validateSessionConfiguration(sessionLength, expireInactiveSessions);
    }
  }, {
    key: 'validateAccountLockoutPolicy',
    value: function validateAccountLockoutPolicy(accountLockout) {
      if (accountLockout) {
        if (typeof accountLockout.duration !== 'number' || accountLockout.duration <= 0 || accountLockout.duration > 99999) {
          throw 'Account lockout duration should be greater than 0 and less than 100000';
        }
 
        if (!Number.isInteger(accountLockout.threshold) || accountLockout.threshold < 1 || accountLockout.threshold > 999) {
          throw 'Account lockout threshold should be an integer greater than 0 and less than 1000';
        }
      }
    }
  }, {
    key: 'validatePasswordPolicy',
    value: function validatePasswordPolicy(passwordPolicy) {
      if (passwordPolicy) {
        if (passwordPolicy.maxPasswordAge !== undefined && (typeof passwordPolicy.maxPasswordAge !== 'number' || passwordPolicy.maxPasswordAge < 0)) {
          throw 'passwordPolicy.maxPasswordAge must be a positive number';
        }
 
        if (passwordPolicy.resetTokenValidityDuration !== undefined && (typeof passwordPolicy.resetTokenValidityDuration !== 'number' || passwordPolicy.resetTokenValidityDuration <= 0)) {
          throw 'passwordPolicy.resetTokenValidityDuration must be a positive number';
        }
 
        if (passwordPolicy.validatorPattern) {
          if (typeof passwordPolicy.validatorPattern === 'string') {
            passwordPolicy.validatorPattern = new RegExp(passwordPolicy.validatorPattern);
          } else if (!(passwordPolicy.validatorPattern instanceof RegExp)) {
            throw 'passwordPolicy.validatorPattern must be a regex string or RegExp object.';
          }
        }
 
        if (passwordPolicy.validatorCallback && typeof passwordPolicy.validatorCallback !== 'function') {
          throw 'passwordPolicy.validatorCallback must be a function.';
        }
 
        if (passwordPolicy.doNotAllowUsername && typeof passwordPolicy.doNotAllowUsername !== 'boolean') {
          throw 'passwordPolicy.doNotAllowUsername must be a boolean value.';
        }
 
        if (passwordPolicy.maxPasswordHistory && (!Number.isInteger(passwordPolicy.maxPasswordHistory) || passwordPolicy.maxPasswordHistory <= 0 || passwordPolicy.maxPasswordHistory > 20)) {
          throw 'passwordPolicy.maxPasswordHistory must be an integer ranging 0 - 20';
        }
      }
    }
 
    // if the passwordPolicy.validatorPattern is configured then setup a callback to process the pattern
 
  }, {
    key: 'setupPasswordValidator',
    value: function setupPasswordValidator(passwordPolicy) {
      if (passwordPolicy && passwordPolicy.validatorPattern) {
        passwordPolicy.patternValidator = function (value) {
          return passwordPolicy.validatorPattern.test(value);
        };
      }
    }
  }, {
    key: 'validateEmailConfiguration',
    value: function validateEmailConfiguration(_ref2) {
      var emailAdapter = _ref2.emailAdapter,
          appName = _ref2.appName,
          publicServerURL = _ref2.publicServerURL,
          emailVerifyTokenValidityDuration = _ref2.emailVerifyTokenValidityDuration;
 
      if (!emailAdapter) {
        throw 'An emailAdapter is required for e-mail verification and password resets.';
      }
      if (typeof appName !== 'string') {
        throw 'An app name is required for e-mail verification and password resets.';
      }
      if (typeof publicServerURL !== 'string') {
        throw 'A public server url is required for e-mail verification and password resets.';
      }
      if (emailVerifyTokenValidityDuration) {
        if (isNaN(emailVerifyTokenValidityDuration)) {
          throw 'Email verify token validity duration must be a valid number.';
        } else if (emailVerifyTokenValidityDuration <= 0) {
          throw 'Email verify token validity duration must be a value greater than 0.';
        }
      }
    }
  }, {
    key: 'validateSessionConfiguration',
    value: function validateSessionConfiguration(sessionLength, expireInactiveSessions) {
      if (expireInactiveSessions) {
        if (isNaN(sessionLength)) {
          throw 'Session length must be a valid number.';
        } else if (sessionLength <= 0) {
          throw 'Session length must be a value greater than 0.';
        }
      }
    }
  }]);
 
  return Config;
}();
 
exports.default = Config;
 
module.exports = Config;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
 
1
 
 
1
 
1
 
1
 
1
 
1
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ParseMessageQueue = undefined;
 
var _AdapterLoader = require('./Adapters/AdapterLoader');
 
var _EventEmitterMQ = require('./Adapters/MessageQueue/EventEmitterMQ');
 
var ParseMessageQueue = {};
 
ParseMessageQueue.createPublisher = function (config) {
  var adapter = (0, _AdapterLoader.loadAdapter)(config.messageQueueAdapter, _EventEmitterMQ.EventEmitterMQ, config);
  if (typeof adapter.createPublisher !== 'function') {
    throw 'pubSubAdapter should have createPublisher()';
  }
  return adapter.createPublisher(config);
};
 
ParseMessageQueue.createSubscriber = function (config) {
  var adapter = (0, _AdapterLoader.loadAdapter)(config.messageQueueAdapter, _EventEmitterMQ.EventEmitterMQ, config);
  if (typeof adapter.createSubscriber !== 'function') {
    throw 'messageQueueAdapter should have createSubscriber()';
  }
  return adapter.createSubscriber(config);
};
 
exports.ParseMessageQueue = ParseMessageQueue;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
 
 
1
 
 
 
5
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
10
 
1
 
 
 
1
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
1
 
 
1
1
1
1
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { Eif (protoProps) defineProperties(Constructor.prototype, protoProps); Eif (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
var _defaults = require('./defaults');
 
var _defaults2 = _interopRequireDefault(_defaults);
 
var _logger = require('./logger');
 
var logging = _interopRequireWildcard(_logger);
 
var _cache = require('./cache');
 
var _cache2 = _interopRequireDefault(_cache);
 
var _Config = require('./Config');
 
var _Config2 = _interopRequireDefault(_Config);
 
var _PromiseRouter = require('./PromiseRouter');
 
var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter);
 
var _requiredParameter = require('./requiredParameter');
 
var _requiredParameter2 = _interopRequireDefault(_requiredParameter);
 
var _AnalyticsRouter = require('./Routers/AnalyticsRouter');
 
var _ClassesRouter = require('./Routers/ClassesRouter');
 
var _FeaturesRouter = require('./Routers/FeaturesRouter');
 
var _InMemoryCacheAdapter = require('./Adapters/Cache/InMemoryCacheAdapter');
 
var _AnalyticsController = require('./Controllers/AnalyticsController');
 
var _CacheController = require('./Controllers/CacheController');
 
var _AnalyticsAdapter = require('./Adapters/Analytics/AnalyticsAdapter');
 
var _WinstonLoggerAdapter = require('./Adapters/Logger/WinstonLoggerAdapter');
 
var _FilesController = require('./Controllers/FilesController');
 
var _FilesRouter = require('./Routers/FilesRouter');
 
var _FunctionsRouter = require('./Routers/FunctionsRouter');
 
var _GlobalConfigRouter = require('./Routers/GlobalConfigRouter');
 
var _GridStoreAdapter = require('./Adapters/Files/GridStoreAdapter');
 
var _HooksController = require('./Controllers/HooksController');
 
var _HooksRouter = require('./Routers/HooksRouter');
 
var _IAPValidationRouter = require('./Routers/IAPValidationRouter');
 
var _InstallationsRouter = require('./Routers/InstallationsRouter');
 
var _AdapterLoader = require('./Adapters/AdapterLoader');
 
var _LiveQueryController = require('./Controllers/LiveQueryController');
 
var _LoggerController = require('./Controllers/LoggerController');
 
var _LogsRouter = require('./Routers/LogsRouter');
 
var _ParseLiveQueryServer = require('./LiveQuery/ParseLiveQueryServer');
 
var _PublicAPIRouter = require('./Routers/PublicAPIRouter');
 
var _PushController = require('./Controllers/PushController');
 
var _PushQueue = require('./Push/PushQueue');
 
var _PushWorker = require('./Push/PushWorker');
 
var _PushRouter = require('./Routers/PushRouter');
 
var _CloudCodeRouter = require('./Routers/CloudCodeRouter');
 
var _RolesRouter = require('./Routers/RolesRouter');
 
var _SchemasRouter = require('./Routers/SchemasRouter');
 
var _SessionsRouter = require('./Routers/SessionsRouter');
 
var _UserController = require('./Controllers/UserController');
 
var _UsersRouter = require('./Routers/UsersRouter');
 
var _PurgeRouter = require('./Routers/PurgeRouter');
 
var _DatabaseController = require('./Controllers/DatabaseController');
 
var _DatabaseController2 = _interopRequireDefault(_DatabaseController);
 
var _SchemaCache = require('./Controllers/SchemaCache');
 
var _SchemaCache2 = _interopRequireDefault(_SchemaCache);
 
var _parseServerPushAdapter = require('parse-server-push-adapter');
 
var _parseServerPushAdapter2 = _interopRequireDefault(_parseServerPushAdapter);
 
var _MongoStorageAdapter = require('./Adapters/Storage/Mongo/MongoStorageAdapter');
 
var _MongoStorageAdapter2 = _interopRequireDefault(_MongoStorageAdapter);
 
var _PostgresStorageAdapter = require('./Adapters/Storage/Postgres/PostgresStorageAdapter');
 
var _PostgresStorageAdapter2 = _interopRequireDefault(_PostgresStorageAdapter);
 
var _ParseServerRESTController = require('./ParseServerRESTController');
 
function _interopRequireWildcard(obj) { Eif (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
// ParseServer - open-source compatible API Server for Parse apps
 
var batch = require('./batch'),
    bodyParser = require('body-parser'),
    express = require('express'),
    middlewares = require('./middlewares'),
    Parse = require('parse/node').Parse,
    path = require('path'),
    url = require('url'),
    authDataManager = require('./Adapters/Auth');
 
// Mutate the Parse object to add the Cloud Code handlers
addParseCloud();
 
// ParseServer works like a constructor of an express app.
// The args that we understand are:
// "analyticsAdapter": an adapter class for analytics
// "filesAdapter": a class like GridStoreAdapter providing create, get,
//                 and delete
// "loggerAdapter": a class like WinstonLoggerAdapter providing info, error,
//                 and query
// "jsonLogs": log as structured JSON objects
// "databaseURI": a uri like mongodb://localhost:27017/dbname to tell us
//          what database this Parse API connects to.
// "cloud": relative location to cloud code to require, or a function
//          that is given an instance of Parse as a parameter.  Use this instance of Parse
//          to register your cloud code hooks and functions.
// "appId": the application id to host
// "masterKey": the master key for requests to this app
// "collectionPrefix": optional prefix for database collection names
// "fileKey": optional key from Parse dashboard for supporting older files
//            hosted by Parse
// "clientKey": optional key from Parse dashboard
// "dotNetKey": optional key from Parse dashboard
// "restAPIKey": optional key from Parse dashboard
// "webhookKey": optional key from Parse dashboard
// "javascriptKey": optional key from Parse dashboard
// "push": optional key from configure push
// "sessionLength": optional length in seconds for how long Sessions should be valid for
 
var ParseServer = function () {
  function ParseServer(_ref) {
    var _ref$appId = _ref.appId,
        appId = _ref$appId === undefined ? (0, _requiredParameter2.default)('You must provide an appId!') : _ref$appId,
        _ref$masterKey = _ref.masterKey,
        masterKey = _ref$masterKey === undefined ? (0, _requiredParameter2.default)('You must provide a masterKey!') : _ref$masterKey,
        appName = _ref.appName,
        analyticsAdapter = _ref.analyticsAdapter,
        filesAdapter = _ref.filesAdapter,
        push = _ref.push,
        loggerAdapter = _ref.loggerAdapter,
        _ref$jsonLogs = _ref.jsonLogs,
        jsonLogs = _ref$jsonLogs === undefined ? _defaults2.default.jsonLogs : _ref$jsonLogs,
        _ref$logsFolder = _ref.logsFolder,
        logsFolder = _ref$logsFolder === undefined ? _defaults2.default.logsFolder : _ref$logsFolder,
        _ref$verbose = _ref.verbose,
        verbose = _ref$verbose === undefined ? _defaults2.default.verbose : _ref$verbose,
        _ref$logLevel = _ref.logLevel,
        logLevel = _ref$logLevel === undefined ? _defaults2.default.level : _ref$logLevel,
        _ref$silent = _ref.silent,
        silent = _ref$silent === undefined ? _defaults2.default.silent : _ref$silent,
        _ref$databaseURI = _ref.databaseURI,
        databaseURI = _ref$databaseURI === undefined ? _defaults2.default.DefaultMongoURI : _ref$databaseURI,
        databaseOptions = _ref.databaseOptions,
        databaseAdapter = _ref.databaseAdapter,
        cloud = _ref.cloud,
        _ref$collectionPrefix = _ref.collectionPrefix,
        collectionPrefix = _ref$collectionPrefix === undefined ? '' : _ref$collectionPrefix,
        clientKey = _ref.clientKey,
        javascriptKey = _ref.javascriptKey,
        dotNetKey = _ref.dotNetKey,
        restAPIKey = _ref.restAPIKey,
        webhookKey = _ref.webhookKey,
        fileKey = _ref.fileKey,
        _ref$userSensitiveFie = _ref.userSensitiveFields,
        userSensitiveFields = _ref$userSensitiveFie === undefined ? [] : _ref$userSensitiveFie,
        _ref$enableAnonymousU = _ref.enableAnonymousUsers,
        enableAnonymousUsers = _ref$enableAnonymousU === undefined ? _defaults2.default.enableAnonymousUsers : _ref$enableAnonymousU,
        _ref$allowClientClass = _ref.allowClientClassCreation,
        allowClientClassCreation = _ref$allowClientClass === undefined ? _defaults2.default.allowClientClassCreation : _ref$allowClientClass,
        _ref$oauth = _ref.oauth,
        oauth = _ref$oauth === undefined ? {} : _ref$oauth,
        _ref$auth = _ref.auth,
        auth = _ref$auth === undefined ? {} : _ref$auth,
        _ref$serverURL = _ref.serverURL,
        serverURL = _ref$serverURL === undefined ? (0, _requiredParameter2.default)('You must provide a serverURL!') : _ref$serverURL,
        _ref$maxUploadSize = _ref.maxUploadSize,
        maxUploadSize = _ref$maxUploadSize === undefined ? _defaults2.default.maxUploadSize : _ref$maxUploadSize,
        _ref$verifyUserEmails = _ref.verifyUserEmails,
        verifyUserEmails = _ref$verifyUserEmails === undefined ? _defaults2.default.verifyUserEmails : _ref$verifyUserEmails,
        _ref$preventLoginWith = _ref.preventLoginWithUnverifiedEmail,
        preventLoginWithUnverifiedEmail = _ref$preventLoginWith === undefined ? _defaults2.default.preventLoginWithUnverifiedEmail : _ref$preventLoginWith,
        emailVerifyTokenValidityDuration = _ref.emailVerifyTokenValidityDuration,
        accountLockout = _ref.accountLockout,
        passwordPolicy = _ref.passwordPolicy,
        cacheAdapter = _ref.cacheAdapter,
        emailAdapter = _ref.emailAdapter,
        publicServerURL = _ref.publicServerURL,
        _ref$customPages = _ref.customPages,
        customPages = _ref$customPages === undefined ? {
      invalidLink: undefined,
      verifyEmailSuccess: undefined,
      choosePassword: undefined,
      passwordResetSuccess: undefined
    } : _ref$customPages,
        _ref$liveQuery = _ref.liveQuery,
        liveQuery = _ref$liveQuery === undefined ? {} : _ref$liveQuery,
        _ref$sessionLength = _ref.sessionLength,
        sessionLength = _ref$sessionLength === undefined ? _defaults2.default.sessionLength : _ref$sessionLength,
        _ref$expireInactiveSe = _ref.expireInactiveSessions,
        expireInactiveSessions = _ref$expireInactiveSe === undefined ? _defaults2.default.expireInactiveSessions : _ref$expireInactiveSe,
        _ref$revokeSessionOnP = _ref.revokeSessionOnPasswordReset,
        revokeSessionOnPasswordReset = _ref$revokeSessionOnP === undefined ? _defaults2.default.revokeSessionOnPasswordReset : _ref$revokeSessionOnP,
        _ref$schemaCacheTTL = _ref.schemaCacheTTL,
        schemaCacheTTL = _ref$schemaCacheTTL === undefined ? _defaults2.default.schemaCacheTTL : _ref$schemaCacheTTL,
        _ref$enableSingleSche = _ref.enableSingleSchemaCache,
        enableSingleSchemaCache = _ref$enableSingleSche === undefined ? false : _ref$enableSingleSche,
        _ref$__indexBuildComp = _ref.__indexBuildCompletionCallbackForTests,
        __indexBuildCompletionCallbackForTests = _ref$__indexBuildComp === undefined ? function () {} : _ref$__indexBuildComp;
 
    _classCallCheck(this, ParseServer);
 
    // Initialize the node client SDK automatically
    Parse.initialize(appId, javascriptKey || 'unused', masterKey);
    Parse.serverURL = serverURL;
    if ((databaseOptions || databaseURI && databaseURI != _defaults2.default.DefaultMongoURI || collectionPrefix !== '') && databaseAdapter) {
      throw 'You cannot specify both a databaseAdapter and a databaseURI/databaseOptions/collectionPrefix.';
    } else if (!databaseAdapter) {
      databaseAdapter = this.getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions);
    } else {
      databaseAdapter = (0, _AdapterLoader.loadAdapter)(databaseAdapter);
    }
 
    if (!filesAdapter && !databaseURI) {
      throw 'When using an explicit database adapter, you must also use an explicit filesAdapter.';
    }
 
    userSensitiveFields = Array.from(new Set(userSensitiveFields.concat(_defaults2.default.userSensitiveFields, userSensitiveFields)));
 
    var loggerControllerAdapter = (0, _AdapterLoader.loadAdapter)(loggerAdapter, _WinstonLoggerAdapter.WinstonLoggerAdapter, { jsonLogs: jsonLogs, logsFolder: logsFolder, verbose: verbose, logLevel: logLevel, silent: silent });
    var loggerController = new _LoggerController.LoggerController(loggerControllerAdapter, appId);
    logging.setLogger(loggerController);
 
    var filesControllerAdapter = (0, _AdapterLoader.loadAdapter)(filesAdapter, function () {
      return new _GridStoreAdapter.GridStoreAdapter(databaseURI);
    });
    var filesController = new _FilesController.FilesController(filesControllerAdapter, appId);
 
    var pushOptions = Object.assign({}, push);
    var pushQueueOptions = pushOptions.queueOptions || {};
    if (pushOptions.queueOptions) {
      delete pushOptions.queueOptions;
    }
    // Pass the push options too as it works with the default
    var pushAdapter = (0, _AdapterLoader.loadAdapter)(pushOptions && pushOptions.adapter, _parseServerPushAdapter2.default, pushOptions);
    // We pass the options and the base class for the adatper,
    // Note that passing an instance would work too
    var pushController = new _PushController.PushController();
 
    var hasPushSupport = pushAdapter && push;
 
    var disablePushWorker = pushQueueOptions.disablePushWorker;
 
 
    var pushControllerQueue = new _PushQueue.PushQueue(pushQueueOptions);
    var pushWorker = void 0;
    if (!disablePushWorker) {
      pushWorker = new _PushWorker.PushWorker(pushAdapter, pushQueueOptions);
    }
 
    var emailControllerAdapter = (0, _AdapterLoader.loadAdapter)(emailAdapter);
    var userController = new _UserController.UserController(emailControllerAdapter, appId, { verifyUserEmails: verifyUserEmails });
 
    var cacheControllerAdapter = (0, _AdapterLoader.loadAdapter)(cacheAdapter, _InMemoryCacheAdapter.InMemoryCacheAdapter, { appId: appId });
    var cacheController = new _CacheController.CacheController(cacheControllerAdapter, appId);
 
    var analyticsControllerAdapter = (0, _AdapterLoader.loadAdapter)(analyticsAdapter, _AnalyticsAdapter.AnalyticsAdapter);
    var analyticsController = new _AnalyticsController.AnalyticsController(analyticsControllerAdapter);
 
    var liveQueryController = new _LiveQueryController.LiveQueryController(liveQuery);
    var databaseController = new _DatabaseController2.default(databaseAdapter, new _SchemaCache2.default(cacheController, schemaCacheTTL, enableSingleSchemaCache));
    var hooksController = new _HooksController.HooksController(appId, databaseController, webhookKey);
 
    var dbInitPromise = databaseController.performInitialization();
 
    if (Object.keys(oauth).length > 0) {
      /* eslint-disable no-console */
      console.warn('oauth option is deprecated and will be removed in a future release, please use auth option instead');
      if (Object.keys(auth).length > 0) {
        console.warn('You should use only the auth option.');
      }
      /* eslint-enable */
    }
 
    auth = Object.assign({}, oauth, auth);
 
    _cache2.default.put(appId, {
      appId: appId,
      masterKey: masterKey,
      serverURL: serverURL,
      collectionPrefix: collectionPrefix,
      clientKey: clientKey,
      javascriptKey: javascriptKey,
      dotNetKey: dotNetKey,
      restAPIKey: restAPIKey,
      webhookKey: webhookKey,
      fileKey: fileKey,
      analyticsController: analyticsController,
      cacheController: cacheController,
      filesController: filesController,
      pushController: pushController,
      loggerController: loggerController,
      hooksController: hooksController,
      userController: userController,
      verifyUserEmails: verifyUserEmails,
      preventLoginWithUnverifiedEmail: preventLoginWithUnverifiedEmail,
      emailVerifyTokenValidityDuration: emailVerifyTokenValidityDuration,
      accountLockout: accountLockout,
      passwordPolicy: passwordPolicy,
      allowClientClassCreation: allowClientClassCreation,
      authDataManager: authDataManager(auth, enableAnonymousUsers),
      appName: appName,
      publicServerURL: publicServerURL,
      customPages: customPages,
      maxUploadSize: maxUploadSize,
      liveQueryController: liveQueryController,
      sessionLength: Number(sessionLength),
      expireInactiveSessions: expireInactiveSessions,
      jsonLogs: jsonLogs,
      revokeSessionOnPasswordReset: revokeSessionOnPasswordReset,
      databaseController: databaseController,
      schemaCacheTTL: schemaCacheTTL,
      enableSingleSchemaCache: enableSingleSchemaCache,
      userSensitiveFields: userSensitiveFields,
      pushWorker: pushWorker,
      pushControllerQueue: pushControllerQueue,
      hasPushSupport: hasPushSupport
    });
 
    _Config2.default.validate(_cache2.default.get(appId));
    this.config = _cache2.default.get(appId);
    _Config2.default.setupPasswordValidator(this.config.passwordPolicy);
    hooksController.load();
 
    // Note: Tests will start to fail if any validation happens after this is called.
    if (process.env.TESTING) {
      __indexBuildCompletionCallbackForTests(dbInitPromise);
    }
 
    if (cloud) {
      addParseCloud();
      if (typeof cloud === 'function') {
        cloud(Parse);
      } else if (typeof cloud === 'string') {
        require(path.resolve(process.cwd(), cloud));
      } else {
        throw "argument 'cloud' must either be a string or a function";
      }
    }
  }
 
  _createClass(ParseServer, [{
    key: 'getDatabaseAdapter',
    value: function getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions) {
      var protocol = void 0;
      try {
        var parsedURI = url.parse(databaseURI);
        protocol = parsedURI.protocol ? parsedURI.protocol.toLowerCase() : null;
      } catch (e) {/* */}
      switch (protocol) {
        case 'postgres:':
          return new _PostgresStorageAdapter2.default({
            uri: databaseURI,
            collectionPrefix: collectionPrefix,
            databaseOptions: databaseOptions
          });
        default:
          return new _MongoStorageAdapter2.default({
            uri: databaseURI,
            collectionPrefix: collectionPrefix,
            mongoOptions: databaseOptions
          });
      }
    }
  }, {
    key: 'app',
    get: function get() {
      return ParseServer.app(this.config);
    }
  }], [{
    key: 'app',
    value: function app(_ref2) {
      var _ref2$maxUploadSize = _ref2.maxUploadSize,
          maxUploadSize = _ref2$maxUploadSize === undefined ? '20mb' : _ref2$maxUploadSize,
          appId = _ref2.appId;
 
      // This app serves the Parse API directly.
      // It's the equivalent of https://api.parse.com/1 in the hosted Parse API.
      var api = express();
      //api.use("/apps", express.static(__dirname + "/public"));
      // File handling needs to be before default middlewares are applied
      api.use('/', middlewares.allowCrossDomain, new _FilesRouter.FilesRouter().expressRouter({
        maxUploadSize: maxUploadSize
      }));
 
      api.use('/health', function (req, res) {
        return res.sendStatus(200);
      });
 
      api.use('/', bodyParser.urlencoded({ extended: false }), new _PublicAPIRouter.PublicAPIRouter().expressRouter());
 
      api.use(bodyParser.json({ 'type': '*/*', limit: maxUploadSize }));
      api.use(middlewares.allowCrossDomain);
      api.use(middlewares.allowMethodOverride);
      api.use(middlewares.handleParseHeaders);
 
      var appRouter = ParseServer.promiseRouter({ appId: appId });
      api.use(appRouter.expressRouter());
 
      api.use(middlewares.handleParseErrors);
 
      //This causes tests to spew some useless warnings, so disable in test
      if (!process.env.TESTING) {
        process.on('uncaughtException', function (err) {
          if (err.code === "EADDRINUSE") {
            // user-friendly message for this common error
            /* eslint-disable no-console */
            console.error('Unable to listen on port ' + err.port + '. The port is already in use.');
            /* eslint-enable no-console */
            process.exit(0);
          } else {
            throw err;
          }
        });
      }
      if (process.env.PARSE_SERVER_ENABLE_EXPERIMENTAL_DIRECT_ACCESS === '1') {
        Parse.CoreManager.setRESTController((0, _ParseServerRESTController.ParseServerRESTController)(appId, appRouter));
      }
      return api;
    }
  }, {
    key: 'promiseRouter',
    value: function promiseRouter(_ref3) {
      var appId = _ref3.appId;
 
      var routers = [new _ClassesRouter.ClassesRouter(), new _UsersRouter.UsersRouter(), new _SessionsRouter.SessionsRouter(), new _RolesRouter.RolesRouter(), new _AnalyticsRouter.AnalyticsRouter(), new _InstallationsRouter.InstallationsRouter(), new _FunctionsRouter.FunctionsRouter(), new _SchemasRouter.SchemasRouter(), new _PushRouter.PushRouter(), new _LogsRouter.LogsRouter(), new _IAPValidationRouter.IAPValidationRouter(), new _FeaturesRouter.FeaturesRouter(), new _GlobalConfigRouter.GlobalConfigRouter(), new _PurgeRouter.PurgeRouter(), new _HooksRouter.HooksRouter(), new _CloudCodeRouter.CloudCodeRouter()];
 
      var routes = routers.reduce(function (memo, router) {
        return memo.concat(router.routes);
      }, []);
 
      var appRouter = new _PromiseRouter2.default(routes, appId);
 
      batch.mountOnto(appRouter);
      return appRouter;
    }
  }, {
    key: 'createLiveQueryServer',
    value: function createLiveQueryServer(httpServer, config) {
      return new _ParseLiveQueryServer.ParseLiveQueryServer(httpServer, config);
    }
  }]);
 
  return ParseServer;
}();
 
function addParseCloud() {
  var ParseCloud = require("./cloud-code/Parse.Cloud");
  Object.assign(Parse.Cloud, ParseCloud);
  global.Parse = Parse;
}
 
exports.default = ParseServer;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
 
1
 
 
1
1
1
1
1
 
1
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
var Config = require('./Config');
var Auth = require('./Auth');
var RESTController = require('parse/lib/node/RESTController');
var URL = require('url');
var Parse = require('parse/node');
 
function getSessionToken(options) {
  if (options && typeof options.sessionToken === 'string') {
    return Parse.Promise.as(options.sessionToken);
  }
  return Parse.Promise.as(null);
}
 
function getAuth() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var config = arguments[1];
 
  var installationId = options.installationId || 'cloud';
  if (options.useMasterKey) {
    return Parse.Promise.as(new Auth.Auth({ config: config, isMaster: true, installationId: installationId }));
  }
  return getSessionToken(options).then(function (sessionToken) {
    if (sessionToken) {
      options.sessionToken = sessionToken;
      return Auth.getAuthForSessionToken({
        config: config,
        sessionToken: sessionToken,
        installationId: installationId
      });
    } else {
      return Parse.Promise.as(new Auth.Auth({ config: config, installationId: installationId }));
    }
  });
}
 
function ParseServerRESTController(applicationId, router) {
  function handleRequest(method, path) {
    var data = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
    var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
 
    // Store the arguments, for later use if internal fails
    var args = arguments;
 
    var config = new Config(applicationId);
    var serverURL = URL.parse(config.serverURL);
    if (path.indexOf(serverURL.path) === 0) {
      path = path.slice(serverURL.path.length, path.length);
    }
 
    if (path[0] !== "/") {
      path = "/" + path;
    }
 
    if (path === '/batch') {
      var promises = data.requests.map(function (request) {
        return handleRequest(request.method, request.path, request.body, options).then(function (response) {
          return Parse.Promise.as({ success: response });
        }, function (error) {
          return Parse.Promise.as({ error: { code: error.code, error: error.message } });
        });
      });
      return Parse.Promise.all(promises);
    }
 
    var query = void 0;
    if (method === 'GET') {
      query = data;
    }
 
    return new Parse.Promise(function (resolve, reject) {
      getAuth(options, config).then(function (auth) {
        var request = {
          body: data,
          config: config,
          auth: auth,
          info: {
            applicationId: applicationId,
            sessionToken: options.sessionToken
          },
          query: query
        };
        return Promise.resolve().then(function () {
          return router.tryRouteRequest(method, path, request);
        }).then(function (response) {
          resolve(response.response, response.status, response);
        }, function (err) {
          if (err instanceof Parse.Error && err.code == Parse.Error.INVALID_JSON && err.message == 'cannot route ' + method + ' ' + path) {
            RESTController.request.apply(null, args).then(resolve, reject);
          } else {
            reject(err);
          }
        });
      }, reject);
    });
  }
 
  return {
    request: handleRequest,
    ajax: RESTController.ajax
  };
}
 
exports.default = ParseServerRESTController;
exports.ParseServerRESTController = ParseServerRESTController;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
 
 
1
 
 
 
1
 
7
 
 
 
 
 
 
1
 
1
 
1
 
1
 
1
 
1
 
1
 
3
 
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
 
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; Eif ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { Eif (protoProps) defineProperties(Constructor.prototype, protoProps); Iif (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // A router that is based on promises rather than req/res/next.
// This is intended to replace the use of express.Router to handle
// subsections of the API surface.
// This will make it easier to have methods like 'batch' that
// themselves use our routing information, without disturbing express
// components that external developers may be modifying.
 
var _node = require('parse/node');
 
var _node2 = _interopRequireDefault(_node);
 
var _express = require('express');
 
var _express2 = _interopRequireDefault(_express);
 
var _logger = require('./logger');
 
var _logger2 = _interopRequireDefault(_logger);
 
var _util = require('util');
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
var Layer = require('express/lib/router/layer');
 
function validateParameter(key, value) {
  if (key == 'className') {
    if (value.match(/_?[A-Za-z][A-Za-z_0-9]*/)) {
      return value;
    }
  } else if (key == 'objectId') {
    if (value.match(/[A-Za-z0-9]+/)) {
      return value;
    }
  } else {
    return value;
  }
}
 
var PromiseRouter = function () {
  // Each entry should be an object with:
  // path: the path to route, in express format
  // method: the HTTP method that this route handles.
  //   Must be one of: POST, GET, PUT, DELETE
  // handler: a function that takes request, and returns a promise.
  //   Successful handlers should resolve to an object with fields:
  //     status: optional. the http status code. defaults to 200
  //     response: a json object with the content of the response
  //     location: optional. a location header
  function PromiseRouter() {
    var routes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
    var appId = arguments[1];
 
    _classCallCheck(this, PromiseRouter);
 
    this.routes = routes;
    this.appId = appId;
    this.mountRoutes();
  }
 
  // Leave the opportunity to
  // subclasses to mount their routes by overriding
 
 
  _createClass(PromiseRouter, [{
    key: 'mountRoutes',
    value: function mountRoutes() {}
 
    // Merge the routes into this one
 
  }, {
    key: 'merge',
    value: function merge(router) {
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;
 
      try {
        for (var _iterator = router.routes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var route = _step.value;
 
          this.routes.push(route);
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    }
  }, {
    key: 'route',
    value: function route(method, path) {
      for (var _len = arguments.length, handlers = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
        handlers[_key - 2] = arguments[_key];
      }
 
      switch (method) {
        case 'POST':
        case 'GET':
        case 'PUT':
        case 'DELETE':
          break;
        default:
          throw 'cannot route method: ' + method;
      }
 
      var handler = handlers[0];
 
      if (handlers.length > 1) {
        handler = function handler(req) {
          return handlers.reduce(function (promise, handler) {
            return promise.then(function () {
              return handler(req);
            });
          }, Promise.resolve());
        };
      }
 
      this.routes.push({
        path: path,
        method: method,
        handler: handler,
        layer: new Layer(path, null, handler)
      });
    }
 
    // Returns an object with:
    //   handler: the handler that should deal with this request
    //   params: any :-params that got parsed from the path
    // Returns undefined if there is no match.
 
  }, {
    key: 'match',
    value: function match(method, path) {
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;
 
      try {
        for (var _iterator2 = this.routes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          var route = _step2.value;
 
          if (route.method != method) {
            continue;
          }
          var layer = route.layer || new Layer(route.path, null, route.handler);
          var match = layer.match(path);
          if (match) {
            var _ret = function () {
              var params = layer.params;
              Object.keys(params).forEach(function (key) {
                params[key] = validateParameter(key, params[key]);
              });
              return {
                v: { params: params, handler: route.handler }
              };
            }();
 
            if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
          }
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }
    }
 
    // Mount the routes on this router onto an express app (or express router)
 
  }, {
    key: 'mountOnto',
    value: function mountOnto(expressApp) {
      var _this = this;
 
      this.routes.forEach(function (route) {
        var method = route.method.toLowerCase();
        var handler = makeExpressHandler(_this.appId, route.handler);
        expressApp[method].call(expressApp, route.path, handler);
      });
      return expressApp;
    }
  }, {
    key: 'expressRouter',
    value: function expressRouter() {
      return this.mountOnto(_express2.default.Router());
    }
  }, {
    key: 'tryRouteRequest',
    value: function tryRouteRequest(method, path, request) {
      var match = this.match(method, path);
      if (!match) {
        throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'cannot route ' + method + ' ' + path);
      }
      request.params = match.params;
      return new Promise(function (resolve, reject) {
        match.handler(request).then(resolve, reject);
      });
    }
  }]);
 
  return PromiseRouter;
}();
 
// A helper function to make an express handler out of a a promise
// handler.
// Express handlers should never throw; if a promise handler throws we
// just treat it like it resolved to an error.
 
 
exports.default = PromiseRouter;
function makeExpressHandler(appId, promiseHandler) {
  return function (req, res, next) {
    try {
      var url = maskSensitiveUrl(req);
      var body = Object.assign({}, req.body);
      var stringifiedBody = JSON.stringify(body, null, 2);
      _logger2.default.verbose('REQUEST for [' + req.method + '] ' + url + ': ' + stringifiedBody, {
        method: req.method,
        url: url,
        headers: req.headers,
        body: body
      });
      promiseHandler(req).then(function (result) {
        if (!result.response && !result.location && !result.text) {
          _logger2.default.error('the handler did not include a "response" or a "location" field');
          throw 'control should not get here';
        }
 
        var stringifiedResponse = JSON.stringify(result, null, 2);
        _logger2.default.verbose('RESPONSE from [' + req.method + '] ' + url + ': ' + stringifiedResponse, { result: result });
 
        var status = result.status || 200;
        res.status(status);
 
        if (result.text) {
          res.send(result.text);
          return;
        }
 
        if (result.location) {
          res.set('Location', result.location);
          // Override the default expressjs response
          // as it double encodes %encoded chars in URL
          if (!result.response) {
            res.send('Found. Redirecting to ' + result.location);
            return;
          }
        }
        if (result.headers) {
          Object.keys(result.headers).forEach(function (header) {
            res.set(header, result.headers[header]);
          });
        }
        res.json(result.response);
      }, function (e) {
        _logger2.default.error('Error generating response. ' + (0, _util.inspect)(e), { error: e });
        next(e);
      });
    } catch (e) {
      _logger2.default.error('Error handling request: ' + (0, _util.inspect)(e), { error: e });
      next(e);
    }
  };
}
 
function maskSensitiveUrl(req) {
  var maskUrl = req.originalUrl.toString();
  var shouldMaskUrl = req.method === 'GET' && req.originalUrl.includes('/login') && !req.originalUrl.includes('classes');
  if (shouldMaskUrl) {
    maskUrl = _logger2.default.maskSensitiveUrl(maskUrl);
  }
  return maskUrl;
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
 
 
1
 
 
 
 
1
1
1
 
1
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
 
// An object that encapsulates everything we need to run a 'find'
// operation, encoded in the REST API format.
 
var SchemaController = require('./Controllers/SchemaController');
var Parse = require('parse/node').Parse;
var triggers = require('./triggers');
 
var AlwaysSelectedKeys = ['objectId', 'createdAt', 'updatedAt'];
// restOptions can include:
//   skip
//   limit
//   order
//   count
//   include
//   keys
//   redirectClassNameForKey
function RestQuery(config, auth, className) {
  var restWhere = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
  var restOptions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
  var clientSDK = arguments[5];
 
 
  this.config = config;
  this.auth = auth;
  this.className = className;
  this.restWhere = restWhere;
  this.restOptions = restOptions;
  this.clientSDK = clientSDK;
  this.response = null;
  this.findOptions = {};
  if (!this.auth.isMaster) {
    this.findOptions.acl = this.auth.user ? [this.auth.user.id] : null;
    if (this.className == '_Session') {
      if (!this.findOptions.acl) {
        throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'This session token is invalid.');
      }
      this.restWhere = {
        '$and': [this.restWhere, {
          'user': {
            __type: 'Pointer',
            className: '_User',
            objectId: this.auth.user.id
          }
        }]
      };
    }
  }
 
  this.doCount = false;
 
  // The format for this.include is not the same as the format for the
  // include option - it's the paths we should include, in order,
  // stored as arrays, taking into account that we need to include foo
  // before including foo.bar. Also it should dedupe.
  // For example, passing an arg of include=foo.bar,foo.baz could lead to
  // this.include = [['foo'], ['foo', 'baz'], ['foo', 'bar']]
  this.include = [];
 
  // If we have keys, we probably want to force some includes (n-1 level)
  // See issue: https://github.com/ParsePlatform/parse-server/issues/3185
  if (restOptions.hasOwnProperty('keys')) {
    var keysForInclude = restOptions.keys.split(',').filter(function (key) {
      // At least 2 components
      return key.split(".").length > 1;
    }).map(function (key) {
      // Slice the last component (a.b.c -> a.b)
      // Otherwise we'll include one level too much.
      return key.slice(0, key.lastIndexOf("."));
    }).join(',');
 
    // Concat the possibly present include string with the one from the keys
    // Dedup / sorting is handle in 'include' case.
    if (keysForInclude.length > 0) {
      if (!restOptions.include || restOptions.include.length == 0) {
        restOptions.include = keysForInclude;
      } else {
        restOptions.include += "," + keysForInclude;
      }
    }
  }
 
  for (var option in restOptions) {
    switch (option) {
      case 'keys':
        {
          var keys = restOptions.keys.split(',').concat(AlwaysSelectedKeys);
          this.keys = Array.from(new Set(keys));
          break;
        }
      case 'count':
        this.doCount = true;
        break;
      case 'skip':
      case 'limit':
        this.findOptions[option] = restOptions[option];
        break;
      case 'order':
        var fields = restOptions.order.split(',');
        this.findOptions.sort = fields.reduce(function (sortMap, field) {
          field = field.trim();
          if (field[0] == '-') {
            sortMap[field.slice(1)] = -1;
          } else {
            sortMap[field] = 1;
          }
          return sortMap;
        }, {});
        break;
      case 'include':
        {
          var paths = restOptions.include.split(',');
          // Load the existing includes (from keys)
          var pathSet = paths.reduce(function (memo, path) {
            // Split each paths on . (a.b.c -> [a,b,c])
            // reduce to create all paths
            // ([a,b,c] -> {a: true, 'a.b': true, 'a.b.c': true})
            return path.split('.').reduce(function (memo, path, index, parts) {
              memo[parts.slice(0, index + 1).join('.')] = true;
              return memo;
            }, memo);
          }, {});
 
          this.include = Object.keys(pathSet).map(function (s) {
            return s.split('.');
          }).sort(function (a, b) {
            return a.length - b.length; // Sort by number of components
          });
          break;
        }
      case 'redirectClassNameForKey':
        this.redirectKey = restOptions.redirectClassNameForKey;
        this.redirectClassName = null;
        break;
      default:
        throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad option: ' + option);
    }
  }
}
 
// A convenient method to perform all the steps of processing a query
// in order.
// Returns a promise for the response - an object with optional keys
// 'results' and 'count'.
// TODO: consolidate the replaceX functions
RestQuery.prototype.execute = function (executeOptions) {
  var _this = this;
 
  return Promise.resolve().then(function () {
    return _this.buildRestWhere();
  }).then(function () {
    return _this.runFind(executeOptions);
  }).then(function () {
    return _this.runCount();
  }).then(function () {
    return _this.handleInclude();
  }).then(function () {
    return _this.runAfterFindTrigger();
  }).then(function () {
    return _this.response;
  });
};
 
RestQuery.prototype.buildRestWhere = function () {
  var _this2 = this;
 
  return Promise.resolve().then(function () {
    return _this2.getUserAndRoleACL();
  }).then(function () {
    return _this2.redirectClassNameForKey();
  }).then(function () {
    return _this2.validateClientClassCreation();
  }).then(function () {
    return _this2.replaceSelect();
  }).then(function () {
    return _this2.replaceDontSelect();
  }).then(function () {
    return _this2.replaceInQuery();
  }).then(function () {
    return _this2.replaceNotInQuery();
  });
};
 
// Uses the Auth object to get the list of roles, adds the user id
RestQuery.prototype.getUserAndRoleACL = function () {
  var _this3 = this;
 
  if (this.auth.isMaster || !this.auth.user) {
    return Promise.resolve();
  }
  return this.auth.getUserRoles().then(function (roles) {
    // Concat with the roles to prevent duplications on multiple calls
    var aclSet = new Set([].concat(_this3.findOptions.acl, roles));
    _this3.findOptions.acl = Array.from(aclSet);
    return Promise.resolve();
  });
};
 
// Changes the className if redirectClassNameForKey is set.
// Returns a promise.
RestQuery.prototype.redirectClassNameForKey = function () {
  var _this4 = this;
 
  if (!this.redirectKey) {
    return Promise.resolve();
  }
 
  // We need to change the class name based on the schema
  return this.config.database.redirectClassNameForKey(this.className, this.redirectKey).then(function (newClassName) {
    _this4.className = newClassName;
    _this4.redirectClassName = newClassName;
  });
};
 
// Validates this operation against the allowClientClassCreation config.
RestQuery.prototype.validateClientClassCreation = function () {
  var _this5 = this;
 
  if (this.config.allowClientClassCreation === false && !this.auth.isMaster && SchemaController.systemClasses.indexOf(this.className) === -1) {
    return this.config.database.loadSchema().then(function (schemaController) {
      return schemaController.hasClass(_this5.className);
    }).then(function (hasClass) {
      if (hasClass !== true) {
        throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'This user is not allowed to access ' + 'non-existent class: ' + _this5.className);
      }
    });
  } else {
    return Promise.resolve();
  }
};
 
function transformInQuery(inQueryObject, className, results) {
  var values = [];
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;
 
  try {
    for (var _iterator = results[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var result = _step.value;
 
      values.push({
        __type: 'Pointer',
        className: className,
        objectId: result.objectId
      });
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }
 
  delete inQueryObject['$inQuery'];
  if (Array.isArray(inQueryObject['$in'])) {
    inQueryObject['$in'] = inQueryObject['$in'].concat(values);
  } else {
    inQueryObject['$in'] = values;
  }
}
 
// Replaces a $inQuery clause by running the subquery, if there is an
// $inQuery clause.
// The $inQuery clause turns into an $in with values that are just
// pointers to the objects returned in the subquery.
RestQuery.prototype.replaceInQuery = function () {
  var _this6 = this;
 
  var inQueryObject = findObjectWithKey(this.restWhere, '$inQuery');
  if (!inQueryObject) {
    return;
  }
 
  // The inQuery value must have precisely two keys - where and className
  var inQueryValue = inQueryObject['$inQuery'];
  if (!inQueryValue.where || !inQueryValue.className) {
    throw new Parse.Error(Parse.Error.INVALID_QUERY, 'improper usage of $inQuery');
  }
 
  var additionalOptions = {
    redirectClassNameForKey: inQueryValue.redirectClassNameForKey
  };
 
  var subquery = new RestQuery(this.config, this.auth, inQueryValue.className, inQueryValue.where, additionalOptions);
  return subquery.execute().then(function (response) {
    transformInQuery(inQueryObject, subquery.className, response.results);
    // Recurse to repeat
    return _this6.replaceInQuery();
  });
};
 
function transformNotInQuery(notInQueryObject, className, results) {
  var values = [];
  var _iteratorNormalCompletion2 = true;
  var _didIteratorError2 = false;
  var _iteratorError2 = undefined;
 
  try {
    for (var _iterator2 = results[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
      var result = _step2.value;
 
      values.push({
        __type: 'Pointer',
        className: className,
        objectId: result.objectId
      });
    }
  } catch (err) {
    _didIteratorError2 = true;
    _iteratorError2 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion2 && _iterator2.return) {
        _iterator2.return();
      }
    } finally {
      if (_didIteratorError2) {
        throw _iteratorError2;
      }
    }
  }
 
  delete notInQueryObject['$notInQuery'];
  if (Array.isArray(notInQueryObject['$nin'])) {
    notInQueryObject['$nin'] = notInQueryObject['$nin'].concat(values);
  } else {
    notInQueryObject['$nin'] = values;
  }
}
 
// Replaces a $notInQuery clause by running the subquery, if there is an
// $notInQuery clause.
// The $notInQuery clause turns into a $nin with values that are just
// pointers to the objects returned in the subquery.
RestQuery.prototype.replaceNotInQuery = function () {
  var _this7 = this;
 
  var notInQueryObject = findObjectWithKey(this.restWhere, '$notInQuery');
  if (!notInQueryObject) {
    return;
  }
 
  // The notInQuery value must have precisely two keys - where and className
  var notInQueryValue = notInQueryObject['$notInQuery'];
  if (!notInQueryValue.where || !notInQueryValue.className) {
    throw new Parse.Error(Parse.Error.INVALID_QUERY, 'improper usage of $notInQuery');
  }
 
  var additionalOptions = {
    redirectClassNameForKey: notInQueryValue.redirectClassNameForKey
  };
 
  var subquery = new RestQuery(this.config, this.auth, notInQueryValue.className, notInQueryValue.where, additionalOptions);
  return subquery.execute().then(function (response) {
    transformNotInQuery(notInQueryObject, subquery.className, response.results);
    // Recurse to repeat
    return _this7.replaceNotInQuery();
  });
};
 
var transformSelect = function transformSelect(selectObject, key, objects) {
  var values = [];
  var _iteratorNormalCompletion3 = true;
  var _didIteratorError3 = false;
  var _iteratorError3 = undefined;
 
  try {
    for (var _iterator3 = objects[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
      var result = _step3.value;
 
      values.push(result[key]);
    }
  } catch (err) {
    _didIteratorError3 = true;
    _iteratorError3 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion3 && _iterator3.return) {
        _iterator3.return();
      }
    } finally {
      if (_didIteratorError3) {
        throw _iteratorError3;
      }
    }
  }
 
  delete selectObject['$select'];
  if (Array.isArray(selectObject['$in'])) {
    selectObject['$in'] = selectObject['$in'].concat(values);
  } else {
    selectObject['$in'] = values;
  }
};
 
// Replaces a $select clause by running the subquery, if there is a
// $select clause.
// The $select clause turns into an $in with values selected out of
// the subquery.
// Returns a possible-promise.
RestQuery.prototype.replaceSelect = function () {
  var _this8 = this;
 
  var selectObject = findObjectWithKey(this.restWhere, '$select');
  if (!selectObject) {
    return;
  }
 
  // The select value must have precisely two keys - query and key
  var selectValue = selectObject['$select'];
  // iOS SDK don't send where if not set, let it pass
  if (!selectValue.query || !selectValue.key || _typeof(selectValue.query) !== 'object' || !selectValue.query.className || Object.keys(selectValue).length !== 2) {
    throw new Parse.Error(Parse.Error.INVALID_QUERY, 'improper usage of $select');
  }
 
  var additionalOptions = {
    redirectClassNameForKey: selectValue.query.redirectClassNameForKey
  };
 
  var subquery = new RestQuery(this.config, this.auth, selectValue.query.className, selectValue.query.where, additionalOptions);
  return subquery.execute().then(function (response) {
    transformSelect(selectObject, selectValue.key, response.results);
    // Keep replacing $select clauses
    return _this8.replaceSelect();
  });
};
 
var transformDontSelect = function transformDontSelect(dontSelectObject, key, objects) {
  var values = [];
  var _iteratorNormalCompletion4 = true;
  var _didIteratorError4 = false;
  var _iteratorError4 = undefined;
 
  try {
    for (var _iterator4 = objects[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
      var result = _step4.value;
 
      values.push(result[key]);
    }
  } catch (err) {
    _didIteratorError4 = true;
    _iteratorError4 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion4 && _iterator4.return) {
        _iterator4.return();
      }
    } finally {
      if (_didIteratorError4) {
        throw _iteratorError4;
      }
    }
  }
 
  delete dontSelectObject['$dontSelect'];
  if (Array.isArray(dontSelectObject['$nin'])) {
    dontSelectObject['$nin'] = dontSelectObject['$nin'].concat(values);
  } else {
    dontSelectObject['$nin'] = values;
  }
};
 
// Replaces a $dontSelect clause by running the subquery, if there is a
// $dontSelect clause.
// The $dontSelect clause turns into an $nin with values selected out of
// the subquery.
// Returns a possible-promise.
RestQuery.prototype.replaceDontSelect = function () {
  var _this9 = this;
 
  var dontSelectObject = findObjectWithKey(this.restWhere, '$dontSelect');
  if (!dontSelectObject) {
    return;
  }
 
  // The dontSelect value must have precisely two keys - query and key
  var dontSelectValue = dontSelectObject['$dontSelect'];
  if (!dontSelectValue.query || !dontSelectValue.key || _typeof(dontSelectValue.query) !== 'object' || !dontSelectValue.query.className || Object.keys(dontSelectValue).length !== 2) {
    throw new Parse.Error(Parse.Error.INVALID_QUERY, 'improper usage of $dontSelect');
  }
  var additionalOptions = {
    redirectClassNameForKey: dontSelectValue.query.redirectClassNameForKey
  };
 
  var subquery = new RestQuery(this.config, this.auth, dontSelectValue.query.className, dontSelectValue.query.where, additionalOptions);
  return subquery.execute().then(function (response) {
    transformDontSelect(dontSelectObject, dontSelectValue.key, response.results);
    // Keep replacing $dontSelect clauses
    return _this9.replaceDontSelect();
  });
};
 
var cleanResultOfSensitiveUserInfo = function cleanResultOfSensitiveUserInfo(result, auth, config) {
  delete result.password;
 
  if (auth.isMaster || auth.user && auth.user.id === result.objectId) {
    return;
  }
 
  var _iteratorNormalCompletion5 = true;
  var _didIteratorError5 = false;
  var _iteratorError5 = undefined;
 
  try {
    for (var _iterator5 = config.userSensitiveFields[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
      var field = _step5.value;
 
      delete result[field];
    }
  } catch (err) {
    _didIteratorError5 = true;
    _iteratorError5 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion5 && _iterator5.return) {
        _iterator5.return();
      }
    } finally {
      if (_didIteratorError5) {
        throw _iteratorError5;
      }
    }
  }
};
 
var cleanResultAuthData = function cleanResultAuthData(result) {
  if (result.authData) {
    Object.keys(result.authData).forEach(function (provider) {
      if (result.authData[provider] === null) {
        delete result.authData[provider];
      }
    });
 
    if (Object.keys(result.authData).length == 0) {
      delete result.authData;
    }
  }
};
 
// Returns a promise for whether it was successful.
// Populates this.response with an object that only has 'results'.
RestQuery.prototype.runFind = function () {
  var _this10 = this;
 
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
  if (this.findOptions.limit === 0) {
    this.response = { results: [] };
    return Promise.resolve();
  }
  var findOptions = Object.assign({}, this.findOptions);
  if (this.keys) {
    findOptions.keys = this.keys.map(function (key) {
      return key.split('.')[0];
    });
  }
  if (options.op) {
    findOptions.op = options.op;
  }
  return this.config.database.find(this.className, this.restWhere, findOptions).then(function (results) {
    if (_this10.className === '_User') {
      var _iteratorNormalCompletion6 = true;
      var _didIteratorError6 = false;
      var _iteratorError6 = undefined;
 
      try {
        for (var _iterator6 = results[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
          var result = _step6.value;
 
          cleanResultOfSensitiveUserInfo(result, _this10.auth, _this10.config);
          cleanResultAuthData(result);
        }
      } catch (err) {
        _didIteratorError6 = true;
        _iteratorError6 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion6 && _iterator6.return) {
            _iterator6.return();
          }
        } finally {
          if (_didIteratorError6) {
            throw _iteratorError6;
          }
        }
      }
    }
 
    _this10.config.filesController.expandFilesInObject(_this10.config, results);
 
    if (_this10.redirectClassName) {
      var _iteratorNormalCompletion7 = true;
      var _didIteratorError7 = false;
      var _iteratorError7 = undefined;
 
      try {
        for (var _iterator7 = results[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
          var r = _step7.value;
 
          r.className = _this10.redirectClassName;
        }
      } catch (err) {
        _didIteratorError7 = true;
        _iteratorError7 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion7 && _iterator7.return) {
            _iterator7.return();
          }
        } finally {
          if (_didIteratorError7) {
            throw _iteratorError7;
          }
        }
      }
    }
    _this10.response = { results: results };
  });
};
 
// Returns a promise for whether it was successful.
// Populates this.response.count with the count
RestQuery.prototype.runCount = function () {
  var _this11 = this;
 
  if (!this.doCount) {
    return;
  }
  this.findOptions.count = true;
  delete this.findOptions.skip;
  delete this.findOptions.limit;
  return this.config.database.find(this.className, this.restWhere, this.findOptions).then(function (c) {
    _this11.response.count = c;
  });
};
 
// Augments this.response with data at the paths provided in this.include.
RestQuery.prototype.handleInclude = function () {
  var _this12 = this;
 
  if (this.include.length == 0) {
    return;
  }
 
  var pathResponse = includePath(this.config, this.auth, this.response, this.include[0], this.restOptions);
  if (pathResponse.then) {
    return pathResponse.then(function (newResponse) {
      _this12.response = newResponse;
      _this12.include = _this12.include.slice(1);
      return _this12.handleInclude();
    });
  } else if (this.include.length > 0) {
    this.include = this.include.slice(1);
    return this.handleInclude();
  }
 
  return pathResponse;
};
 
//Returns a promise of a processed set of results
RestQuery.prototype.runAfterFindTrigger = function () {
  var _this13 = this;
 
  if (!this.response) {
    return;
  }
  // Avoid doing any setup for triggers if there is no 'afterFind' trigger for this class.
  var hasAfterFindHook = triggers.triggerExists(this.className, triggers.Types.afterFind, this.config.applicationId);
  if (!hasAfterFindHook) {
    return Promise.resolve();
  }
  // Run afterFind trigger and set the new results
  return triggers.maybeRunAfterFindTrigger(triggers.Types.afterFind, this.auth, this.className, this.response.results, this.config).then(function (results) {
    _this13.response.results = results;
  });
};
 
// Adds included values to the response.
// Path is a list of field names.
// Returns a promise for an augmented response.
function includePath(config, auth, response, path) {
  var restOptions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
 
  var pointers = findPointers(response.results, path);
  if (pointers.length == 0) {
    return response;
  }
  var pointersHash = {};
  var _iteratorNormalCompletion8 = true;
  var _didIteratorError8 = false;
  var _iteratorError8 = undefined;
 
  try {
    for (var _iterator8 = pointers[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
      var pointer = _step8.value;
 
      if (!pointer) {
        continue;
      }
      var className = pointer.className;
      // only include the good pointers
      if (className) {
        pointersHash[className] = pointersHash[className] || new Set();
        pointersHash[className].add(pointer.objectId);
      }
    }
  } catch (err) {
    _didIteratorError8 = true;
    _iteratorError8 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion8 && _iterator8.return) {
        _iterator8.return();
      }
    } finally {
      if (_didIteratorError8) {
        throw _iteratorError8;
      }
    }
  }
 
  var includeRestOptions = {};
  if (restOptions.keys) {
    var keys = new Set(restOptions.keys.split(','));
    var keySet = Array.from(keys).reduce(function (set, key) {
      var keyPath = key.split('.');
      var i = 0;
      for (i; i < path.length; i++) {
        if (path[i] != keyPath[i]) {
          return set;
        }
      }
      if (i < keyPath.length) {
        set.add(keyPath[i]);
      }
      return set;
    }, new Set());
    if (keySet.size > 0) {
      includeRestOptions.keys = Array.from(keySet).join(',');
    }
  }
 
  var queryPromises = Object.keys(pointersHash).map(function (className) {
    var where = { 'objectId': { '$in': Array.from(pointersHash[className]) } };
    var query = new RestQuery(config, auth, className, where, includeRestOptions);
    return query.execute({ op: 'get' }).then(function (results) {
      results.className = className;
      return Promise.resolve(results);
    });
  });
 
  // Get the objects for all these object ids
  return Promise.all(queryPromises).then(function (responses) {
    var replace = responses.reduce(function (replace, includeResponse) {
      var _iteratorNormalCompletion9 = true;
      var _didIteratorError9 = false;
      var _iteratorError9 = undefined;
 
      try {
        for (var _iterator9 = includeResponse.results[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
          var obj = _step9.value;
 
          obj.__type = 'Object';
          obj.className = includeResponse.className;
 
          if (obj.className == "_User" && !auth.isMaster) {
            delete obj.sessionToken;
            delete obj.authData;
          }
          replace[obj.objectId] = obj;
        }
      } catch (err) {
        _didIteratorError9 = true;
        _iteratorError9 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion9 && _iterator9.return) {
            _iterator9.return();
          }
        } finally {
          if (_didIteratorError9) {
            throw _iteratorError9;
          }
        }
      }
 
      return replace;
    }, {});
 
    var resp = {
      results: replacePointers(response.results, path, replace)
    };
    if (response.count) {
      resp.count = response.count;
    }
    return resp;
  });
}
 
// Object may be a list of REST-format object to find pointers in, or
// it may be a single object.
// If the path yields things that aren't pointers, this throws an error.
// Path is a list of fields to search into.
// Returns a list of pointers in REST format.
function findPointers(object, path) {
  if (object instanceof Array) {
    var answer = [];
    var _iteratorNormalCompletion10 = true;
    var _didIteratorError10 = false;
    var _iteratorError10 = undefined;
 
    try {
      for (var _iterator10 = object[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
        var x = _step10.value;
 
        answer = answer.concat(findPointers(x, path));
      }
    } catch (err) {
      _didIteratorError10 = true;
      _iteratorError10 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion10 && _iterator10.return) {
          _iterator10.return();
        }
      } finally {
        if (_didIteratorError10) {
          throw _iteratorError10;
        }
      }
    }
 
    return answer;
  }
 
  if ((typeof object === 'undefined' ? 'undefined' : _typeof(object)) !== 'object' || !object) {
    return [];
  }
 
  if (path.length == 0) {
    if (object === null || object.__type == 'Pointer') {
      return [object];
    }
    return [];
  }
 
  var subobject = object[path[0]];
  if (!subobject) {
    return [];
  }
  return findPointers(subobject, path.slice(1));
}
 
// Object may be a list of REST-format objects to replace pointers
// in, or it may be a single object.
// Path is a list of fields to search into.
// replace is a map from object id -> object.
// Returns something analogous to object, but with the appropriate
// pointers inflated.
function replacePointers(object, path, replace) {
  if (object instanceof Array) {
    return object.map(function (obj) {
      return replacePointers(obj, path, replace);
    }).filter(function (obj) {
      return typeof obj !== 'undefined';
    });
  }
 
  if ((typeof object === 'undefined' ? 'undefined' : _typeof(object)) !== 'object' || !object) {
    return object;
  }
 
  if (path.length === 0) {
    if (object && object.__type === 'Pointer') {
      return replace[object.objectId];
    }
    return object;
  }
 
  var subobject = object[path[0]];
  if (!subobject) {
    return object;
  }
  var newsub = replacePointers(subobject, path.slice(1), replace);
  var answer = {};
  for (var key in object) {
    if (key == path[0]) {
      answer[key] = newsub;
    } else {
      answer[key] = object[key];
    }
  }
  return answer;
}
 
// Finds a subobject that has the given key, if there is one.
// Returns undefined otherwise.
function findObjectWithKey(root, key) {
  if ((typeof root === 'undefined' ? 'undefined' : _typeof(root)) !== 'object') {
    return;
  }
  if (root instanceof Array) {
    var _iteratorNormalCompletion11 = true;
    var _didIteratorError11 = false;
    var _iteratorError11 = undefined;
 
    try {
      for (var _iterator11 = root[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
        var item = _step11.value;
 
        var answer = findObjectWithKey(item, key);
        if (answer) {
          return answer;
        }
      }
    } catch (err) {
      _didIteratorError11 = true;
      _iteratorError11 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion11 && _iterator11.return) {
          _iterator11.return();
        }
      } finally {
        if (_didIteratorError11) {
          throw _iteratorError11;
        }
      }
    }
  }
  if (root && root[key]) {
    return root;
  }
  for (var subkey in root) {
    var _answer = findObjectWithKey(root[subkey], key);
    if (_answer) {
      return _answer;
    }
  }
}
 
module.exports = RestQuery;